// Serve - minimal Java servlet container class
//
// Copyright (C)1996,1998 by Jef Poskanzer <jef@acme.com>. All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
// 1. Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
// OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
// SUCH DAMAGE.
//
// Visit the ACME Labs Java page for up-to-date versions of this and other
// fine Java utilities: http://www.acme.com/java/
//

// All enhancements Copyright (C)1998-2010 by Dmitriy Rogatkin
// This version is compatible with JSDK 2.5
// http://tjws.sourceforge.net
// $Id: Serve.java,v 1.194 2009/12/31 05:02:13 dmitriy Exp $

package Acme.Serve;

import Acme.Utils;

import javax.servlet.RequestDispatcher;
import javax.servlet.Servlet;
import javax.servlet.ServletConfig;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletInputStream;
import javax.servlet.ServletOutputStream;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.SingleThreadModel;
import javax.servlet.UnavailableException;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import javax.servlet.http.HttpSessionActivationListener;
import javax.servlet.http.HttpSessionAttributeListener;
import javax.servlet.http.HttpSessionBindingEvent;
import javax.servlet.http.HttpSessionBindingListener;
import javax.servlet.http.HttpSessionContext;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.Serializable;
import java.io.StringWriter;
import java.io.UnsupportedEncodingException;
import java.io.Writer;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.InetAddress;
import java.net.MalformedURLException;
import java.net.Socket;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.security.SecureRandom;
import java.text.MessageFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Properties;
import java.util.StringTokenizer;
import java.util.TimeZone;
import java.util.TreeSet;
import java.util.Vector;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.logging.SimpleFormatter;
import java.util.logging.StreamHandler;

/// Minimal Java servlet container class.
// <P>
// This class implements a very small embeddable servlet container.
// It runs Servlets compatible with the API used by Sun's 
// <A HREF="http://docs.sun.com/app/docs/doc/819-3653">Java System Application </A> server.
// Servlet API can be found <A HREF="http://java.sun.com/products/servlet/">here</A>.
// It comes with default Servlets which provide the usual
// httpd services, returning files and directory listings.
// <P>
// This is not in any sense a competitor for Java System Application server.
// Java System Application server is a full-fledged HTTP server and more.
// Acme.Serve is tiny, about 5000 lines, and provides only the
// functionality necessary to deliver an Applet's .class files
// and then start up a Servlet talking to the Applet.
// They are both written in Java, they are both web servers, and
// they both implement the Servlet API; other than that they couldn't
// be more different.
// <P>
// This is actually the second HTTP server I've written.
// The other one is called
// <A HREF="http://www.acme.com/software/thttpd/">thttpd</A>,
// it's written in C, and is also pretty small although much more
// featureful than this.
// <P>
// Other Java HTTP servers:
// <UL>
// <LI> The above-mentioned <A
// HREF="http://docs.sun.com/app/docs/doc/819-3653">JavaServer</A>.
// <LI> W3C's <A HREF="http://www.w3.org/pub/WWW/Jigsaw/">Jigsaw</A>.
// <LI> David Wilkinson's <A
// HREF="http://www.netlink.co.uk/users/cascade/http/">Cascade</A>.
// <LI> Yahoo's <A
// HREF="http://www.yahoo.com/Computers_and_Internet/Software/Internet/World_Wide_Web/Servers/Java/">list
// of Java web servers</A>.
// </UL>
// <P>
// A <A HREF="http://www.byte.com/art/9706/sec8/art1.htm">June 1997 BYTE
// magazine article</A> mentioning this server.<BR>
// A <A HREF="http://www.byte.com/art/9712/sec6/art7.htm">December 1997 BYTE
// magazine article</A> giving it an Editor's Choice Award of Distinction.<BR>
// <A HREF="/resources/classes/Acme/Serve/Serve.java">Fetch the
// software.</A><BR>
// <A HREF="/resources/classes/Acme.tar.Z">Fetch the entire Acme package.</A>
// <P>
// @see Acme.Serve.servlet.http.HttpServlet
// @see FileServlet
// @see CgiServlet
// <h3>Post notes</h3>
// Currently the server 3 more times complex and can compete with
// most popular app and web servers used for deploying of web
// Java applications.

// Inheritance can extend usage of this server

/**
 * @deprecated See resteasy-undertow module.
 */
@SuppressWarnings(value = "unchecked")
@Deprecated
public class Serve implements ServletContext, Serializable
{

   public static final String ARG_PORT = "port";

   public static final String ARG_THROTTLES = "throttles";

   public static final String ARG_SERVLETS = "servlets";

   public static final String ARG_REALMS = "realms";

   public static final String ARG_ALIASES = "aliases";

   public static final String ARG_BINDADDRESS = "bind-address";

   public static final String ARG_BACKLOG = "backlog";

   public static final String ARG_CGI_PATH = "cgi-path";

   public static final String ARG_ERR = "error-stream";

   public static final String ARG_OUT = "out-stream";

   public static final String ARG_SESSION_TIMEOUT = "session-timeout";

   public static final String ARG_LOG_DIR = "log-dir";

   public static final String ARG_LOG_OPTIONS = "log-options";

   public static final String ARG_NOHUP = "nohup";

   public static final String ARG_JSP = "JSP";

   public static final String ARG_WAR = "war-deployer";

   public static final String ARG_KEEPALIVE = "keep-alive";

   public static final String DEF_LOGENCODING = "tjws.serve.log.encoding";

   public static final String ARG_KEEPALIVE_TIMEOUT = "timeout-keep-alive";

   public static final String ARG_MAX_CONN_USE = "max-alive-conn-use";

   public static final String ARG_SESSION_PERSIST = "sssn-persistance";

   public static final String ARG_MAX_ACTIVE_SESSIONS = "max-active-sessions";

   public static final String ARG_ACCESS_LOG_FMT = "access-log-format";

   public static final String ARG_ACCEPTOR_CLASS = "acceptorImpl";

   public static final String ARG_WORK_DIRECTORY = "workdirectory";

   public static final String ARG_SESSION_SEED = "SessionSeed";

   public static final String ARG_THREAD_POOL_SIZE = Utils.ThreadPool.MAXNOTHREAD;


   protected static final int DEF_SESSION_TIMEOUT = 30; // in minutes

   protected static final int DEF_MIN_ACT_SESS = 10;

   protected static final int DESTROY_TIME_SEC = 15;

   protected static final int HTTP_MAX_HDR_LEN = 1024 * 1024 * 10;

   public static final int DEF_PORT = 8080;

   public static final String BGCOLOR = "BGCOLOR=\"#D1E9FE\"";

   /**
    * max number of alive connections default value
    */
   protected static final int DEF_MAX_CONN_USE = 100;

   public static final String UTF8 = StandardCharsets.UTF_8.name(); // default encoding

   protected String hostName;

   private transient Logger log;

   private boolean useAccLog;

   private boolean keepAlive;

   private int timeoutKeepAlive;

   private int maxAliveConnUse;

   private boolean showUserAgent;

   private boolean showReferer;

   protected String keepAliveHdrParams;

   protected transient PathTreeDictionary registry;

   protected transient PathTreeDictionary realms;

   protected transient PathTreeDictionary mappingtable;

   private Hashtable attributes;

   protected transient KeepAliveCleaner keepAliveCleaner;

   protected transient ThreadGroup serverThreads;

   protected transient Utils.ThreadPool threadPool;

   protected transient Constructor gzipInStreamConstr;

   // for sessions
   private byte[] uniqer = new byte[20]; // TODO consider configurable strength

   private SecureRandom srandom;

   protected HttpSessionContextImpl sessions;

   protected int expiredIn;

   public Map arguments;

   public Properties mime;

   protected List<ServeConnection> connections = new ArrayList<ServeConnection>();

   // / Constructor kept for API compatibility
   public Serve(Map arguments, PrintStream logStream) {
      this(arguments, newLoggerForPrintStream(logStream));
   }

   /**
    * Default constructor to create TJWS as a bean
    */
   public Serve()
   {
      this(new HashMap(), Logger.getLogger(Serve.class.getName()));
   }

   private Serve(Map arguments, Logger log)
   {
      this.arguments = arguments;
      this.log = log;
      registry = new PathTreeDictionary();
      realms = new PathTreeDictionary();
      attributes = new Hashtable();
      serverThreads = new ThreadGroup("TJWS threads");
      Properties props = new Properties();
      props.putAll(arguments);
      // TODO do not create thread pool unless requested
      threadPool = new Utils.ThreadPool(props, new Utils.ThreadFactory()
      {
         public Thread create(Runnable runnable)
         {
            Thread result = new Thread(serverThreads, runnable);
            result.setDaemon(true);
            return result;
         }
      });
      setAccessLogged();
      keepAlive = arguments.get(ARG_KEEPALIVE) == null || ((Boolean) arguments.get(ARG_KEEPALIVE)).booleanValue();
      int timeoutKeepAliveSec;
      try
      {
         timeoutKeepAliveSec = Integer.parseInt((String) arguments.get(ARG_KEEPALIVE_TIMEOUT));
      }
      catch (Exception ex)
      {
         timeoutKeepAliveSec = 30;
      }
      timeoutKeepAlive = timeoutKeepAliveSec * 1000;
      try
      {
         maxAliveConnUse = Integer.parseInt((String) arguments.get(ARG_MAX_CONN_USE));
      }
      catch (Exception ex)
      {
         maxAliveConnUse = DEF_MAX_CONN_USE;
      }
      keepAliveHdrParams = "timeout=" + timeoutKeepAliveSec + ", max=" + maxAliveConnUse;

      expiredIn = arguments.get(ARG_SESSION_TIMEOUT) != null ? ((Integer) arguments.get(ARG_SESSION_TIMEOUT))
              .intValue() : DEF_SESSION_TIMEOUT;
      srandom = new SecureRandom((arguments.get(ARG_SESSION_SEED) == null ? "TJWS" + new Date() : (String) arguments.get(ARG_SESSION_SEED)).getBytes());
      try
      {
         gzipInStreamConstr = Class.forName("java.util.zip.GZIPInputStream").getConstructor(new Class[]{InputStream.class});
      }
      catch (ClassNotFoundException cne)
      {

      }
      catch (NoSuchMethodException nsm)
      {

      }
      initMime();
   }

   private static Logger newLoggerForPrintStream(PrintStream printStream) {
      Logger result = Logger.getLogger(Serve.class.getName());
      result.setUseParentHandlers(false);
      result.addHandler(new StreamHandler(printStream, new SimpleFormatter()));
      return result;
   }

   protected void setAccessLogged()
   {
      String logflags = (String) arguments.get(ARG_LOG_OPTIONS);
      if (logflags != null)
      {
         useAccLog = true;
         showUserAgent = logflags.indexOf('A') >= 0;
         showReferer = logflags.indexOf('R') >= 0;
      }
   }

   protected boolean isAccessLogged()
   {
      return useAccLog;
   }

   protected boolean isShowReferer()
   {
      return showReferer;
   }

   protected boolean isShowUserAgent()
   {
      return showUserAgent;
   }

   protected boolean isKeepAlive()
   {
      return keepAlive;
   }

   protected int getKeepAliveDuration()
   {
      return timeoutKeepAlive;
   }

   protected String getKeepAliveParamStr()
   {
      return keepAliveHdrParams;
   }

   protected int getMaxTimesConnectionUse()
   {
      return maxAliveConnUse;
   }

   protected void initMime()
   {
      mime = new Properties();
      try
      {
         InputStream inputStream = getClass().getClassLoader().getResourceAsStream("Acme/Resource/mime.properties");
         if (inputStream != null) {
            mime.load(inputStream);
         } else {
            log("MIME map can't be found");
         }
      }
      catch (Exception ex)
      {
         log("MIME map can't be loaded", ex);
      }
   }

   // / Register a Servlet by class name. Registration consists of a URL
   // pattern, which can contain wildcards, and the class name of the Servlet
   // to launch when a matching URL comes in. Patterns are checked for
   // matches in the order they were added, and only the first match is run.
   public void addServlet(String urlPat, String className)
   {
      addServlet(urlPat, className, (Hashtable) null);
   }

   /**
    * Adds a servlet to run
    *
    * @param urlPat     servlet invoker URL pattern
    * @param className  servlet class name
    * @param initParams servlet init parameters
    */
   public void addServlet(String urlPat, String className, Hashtable initParams)
   {
      // Check if we're allowed to make one of these.
      SecurityManager security = System.getSecurityManager();
      if (security != null)
      {
         int i = className.lastIndexOf('.');
         if (i > 0)
         {
            security.checkPackageAccess(className.substring(0, i));
            security.checkPackageDefinition(className.substring(0, i));
         }
      }

      // Make a new one.
      try
      {
         addServlet(urlPat, (Servlet) Class.forName(className).newInstance(), initParams);
      }
      catch (ClassNotFoundException e)
      {
         log("Class not found: " + className);
         ClassLoader cl = getClass().getClassLoader();
         log("Class loader: " + cl);
         if (cl instanceof java.net.URLClassLoader)
            log("CP: " + java.util.Arrays.asList(((java.net.URLClassLoader) cl).getURLs()));
      }
      catch (ClassCastException e)
      {
         log("Servlet class doesn't implement javax.servlet.Servlet: " + e.getMessage());
      }
      catch (InstantiationException e)
      {
         log("Can't instantiate servlet: " + e.getMessage());
      }
      catch (IllegalAccessException e)
      {
         log("Illegal class access: " + e.getMessage());
      }
      catch (Exception e)
      {
         log("Unexpected problem of servlet creation: " + e, e);
      }
   }

   /**
    * Register a Servlet. Registration consists of a URL pattern,
    * which can contain wildcards, and the Servlet to
    * launch when a matching URL comes in. Patterns are checked for
    * matches in the order they were added, and only the first match is run.
    *
    * @param urlPat  servlet invoker URL pattern
    * @param servlet already instantiated servlet but init
    */
   public void addServlet(String urlPat, Servlet servlet)
   {
      addServlet(urlPat, servlet, (Hashtable) null);
   }

   /**
    * Register a Servlet
    *
    * @param urlPat
    * @param servlet
    * @param initParams
    */
   public synchronized void addServlet(String urlPat, Servlet servlet, Hashtable initParams)
   {
      try
      {
         if (getServlet(urlPat) != null)
            log("Servlet overriden by " + servlet + ", for path:" + urlPat);
         servlet.init(new ServeConfig((ServletContext) this, initParams, urlPat));
         registry.put(urlPat, servlet);
      }
      catch (ServletException e)
      { //
         // it handles UnavailableException as well without an attempt to re-adding
         log("Problem initializing servlet, it won't be used: " + e);
      }
   }

   public Servlet unloadServlet(Servlet servlet)
   {
      Servlet result = null;
      synchronized (registry)
      {
         result = (Servlet) registry.remove(servlet)[0];
      }
      return result;
   }

   public synchronized void unloadServlet(String urlPat)
   {
      Servlet servlet = (Servlet) registry.remove(urlPat)[0];
      if (servlet != null)
         servlet.destroy(); // sessions associated with it have to be invalidated to free up any the servlet specific object
      // TODO decide if UnavailableException should be thrown at access
   }

   // / Register a standard set of Servlets. These will return
   // files or directory listings, and run CGI programs, much like a
   // standard HTTP server.
   // <P>
   // Because of the pattern checking order, this should be called
   // <B>after</B> you've added any custom Servlets.
   // <P>
   // The current set of default servlet mappings:
   // <UL>
   // <LI> If enabled, *.cgi goes to CgiServlet, and gets run as a CGI program.
   // <LI> * goes to FileServlet, and gets served up as a file or directory.
   // </UL>
   // @param cgi whether to run CGI programs
   // TODO: provide user specified CGI directory
   public void addDefaultServlets(String cgi)
   {
      try
      {
         addDefaultServlets(cgi, null);
      }
      catch (IOException ioe)
      { /* ignore, makes sense only for throtles */
      }
   }

   /**
    * Register a standard set of Servlets, with optional throttles. These will return files or directory listings, and run CGI programs, much like a standard
    * HTTP server.
    * <p/>
    * Because of the pattern checking order, this should be called <B>after</B> you've added any custom Servlets.
    * <p/>
    * The current set of default servlet mappings:
    * <UL>
    * <LI> If enabled, *.cgi goes to CgiServlet, and gets run as a CGI program.
    * <LI> * goes to FileServlet, and gets served up as a file or directory.
    * </UL>
    *
    * @param cgi       whether to run CGI programs
    * @param throttles filename to read FileServlet throttle settings from, can be null
    * @throws IOException
    */
   public void addDefaultServlets(String cgi, String throttles) throws IOException
   {
      // TODO: provide user specified CGI directory
      if (cgi != null)
      {
         if (getServlet("/" + cgi) == null)
            addServlet("/" + cgi, new Acme.Serve.CgiServlet());
         else
            log("Servlet for path '/" + cgi + "' already defined and no default will be used.");
      }
      if (getServlet("/") == null)
         if (throttles != null)
            addServlet("/", new Acme.Serve.FileServlet(throttles, null));
         else
            addServlet("/", new Acme.Serve.FileServlet());
      else
         log("Servlet for path '/' already defined and no default will be used.");
   }

   protected void addWarDeployer(String deployerFactory, String throttles)
   {
      if (deployerFactory == null) // try to use def
         deployerFactory = "rogatkin.web.WarRoller";
      try
      {
         WarDeployer wd = (WarDeployer) Class.forName(deployerFactory).newInstance();
         wd.deploy(this);
      }
      catch (ClassNotFoundException cnf)
      {
         log("Problem initializing war deployer: " + cnf);
      }
      catch (Exception e)
      {
         log("Problem war(s) deployment", e);
      }
   }

   protected File getPersistentFile()
   {
      if (arguments.get(ARG_SESSION_PERSIST) == null || (Boolean) arguments.get(ARG_SESSION_PERSIST) == Boolean.FALSE)
         return null;
      String workPath = (String) arguments.get(ARG_WORK_DIRECTORY);
      if (workPath == null)
         workPath = ".";
      return new File(workPath, hostName + '-'
              + (arguments.get(ARG_PORT) == null ? String.valueOf(DEF_PORT) : arguments.get(ARG_PORT))
              + "-session.obj");
   }

   // Run the server. Returns only on errors.
   transient boolean running = true;

   protected transient Acceptor acceptor;

   protected transient Thread ssclThread;

   protected transient boolean initialized;

   protected CountDownLatch shutdownLatch;
   protected Thread backgroundThread;

   public void runInBackground()
   {
      shutdownLatch = new CountDownLatch(1);
      try
      {
         init();
      }
      catch (IOException e)
      {
         throw new RuntimeException(e);
      }
      backgroundThread = new Thread()
      {
         public void run()
         {
            try
            {
               serve();
            }
            finally
            {
               shutdownLatch.countDown();
            }
         }
      };
      backgroundThread.start();

   }

   public void stopBackground()
   {
      try
      {
         notifyStop();
      }
      catch (Throwable ignored)
      {
      }
      try
      {
         if (shutdownLatch.await(100, TimeUnit.MILLISECONDS) == false)
         {
            try
            {
               backgroundThread.interrupt();
            }
            catch (Exception ignored)
            {
            }
         }
         shutdownLatch.await(1, TimeUnit.SECONDS);
      }
      catch (InterruptedException e)
      {
      }
      synchronized(connections)
      {
         for (ServeConnection conn : connections)
         {
            conn.closeSocket();
         }
         connections.clear();
      }
   }

   /**
    * Launches the server
    * It doesn't exist until server runs, so start it in a dedicated thread.
    *
    * @return 0 if the server successfully terminated, 1 if it can't be started and -1 if it
    *         was terminated during some errors
    */
   public int serve()
   {
      try
      {
         while (running)
         {
            try
            {
               Socket socket = acceptor.accept();
               // TODO consider to use ServeConnection object pool
               if (keepAliveCleaner != null) // we need to add regardless of keep alive
                  keepAliveCleaner.addConnection(new ServeConnection(socket, this));
               else
                  new ServeConnection(socket, this); // TODO consider req/resp objects pooling
            }
            catch (IOException e)
            {
               log("Accept: " + e);
            }
            catch (SecurityException se)
            {
               log("Illegal access: " + se);
            }
            catch (IllegalStateException is)
            {
               log("Illegal state: " + is);
            }
         }
      }
      catch (Throwable t)
      {
         log("Unhandled exception: " + t + ", server is terminating.", t);
         if (t instanceof ThreadDeath)
            throw (Error) t;
         return -1;
      }
      finally
      {
         try
         {
            if (acceptor != null)
               acceptor.destroy();
         }
         catch (IOException e)
         {
         }
      }
      return 0;
   }

   public void init() throws IOException
   {
      shutdownLatch = new CountDownLatch(1);
      acceptor = createAcceptor();

      if (expiredIn > 0)
      {
         ssclThread = new Thread(serverThreads, new Runnable()
         {
            public void run()
            {
               while (running)
               {
                  try
                  {
                     Thread.sleep(expiredIn * 60 * 1000);
                  }
                  catch (InterruptedException ie)
                  {
                     if (running == false)
                        break;
                  }
                  Enumeration e = sessions.keys();
                  while (e.hasMoreElements())
                  {
                     Object sid = e.nextElement();
                     if (sid != null)
                     {
                        AcmeSession as = (AcmeSession) sessions.get(sid);
                        if (as != null && (as.checkExpired() || !as.isValid()))
                        { // log("sesion
                           as = (AcmeSession) sessions.remove(sid);
                           if (as != null && as.isValid())
                              try
                              {
                                 as.invalidate();
                              }
                              catch (IllegalStateException ise)
                              {

                              }
                        }
                     }
                  }
               }
            }
         }, "Session cleaner");
         ssclThread.setPriority(Thread.MIN_PRIORITY);
         // ssclThread.setDaemon(true);
         ssclThread.start();
      } // else
      // expiredIn = -expiredIn;
      if (isKeepAlive())
      {
         keepAliveCleaner = new KeepAliveCleaner();
         keepAliveCleaner.start();
      }
      File fsessions = getPersistentFile();
      if (fsessions != null && fsessions.exists())
      {
         BufferedReader br = null;
         try
         {
            br = new BufferedReader(new FileReader(fsessions));
            sessions = HttpSessionContextImpl.restore(br, Math.abs(expiredIn) * 60, this);
         }
         catch (IOException ioe)
         {
            log("Problem in restoring sessions.", ioe);
         }
         catch (Exception e)
         {
            log("Unexpected problem in restoring sessions.", e);
         }
         finally
         {
            if (br != null)
               try
               {
                  br.close();
               }
               catch (IOException ioe)
               {
               }
         }
      }
      if (sessions == null)
         sessions = new HttpSessionContextImpl();
   }

   /**
    * Tells the server to stop
    *
    * @throws IOException
    */
   public void notifyStop() throws IOException
   {
      running = false;
      acceptor.destroy();
      acceptor = null;
      if (ssclThread != null)
         ssclThread.interrupt();
   }

   public static interface Acceptor
   {
      public void init(Map inProperties, Map outProperties) throws IOException;

      public Socket accept() throws IOException;

      public void destroy() throws IOException;
   }

   protected Acceptor createAcceptor() throws IOException
   {
      String acceptorClass = (String) arguments.get(ARG_ACCEPTOR_CLASS);
      if (acceptorClass == null)
         acceptorClass = "Acme.Serve.SimpleAcceptor";
      // assured defaulting here
      try
      {
         acceptor = (Acceptor) Class.forName(acceptorClass).newInstance();
      }
      catch (InstantiationException e)
      {
         log("Couldn't instantiate Acceptor, the Server is inoperable", e);
      }
      catch (IllegalAccessException e)
      {
         Constructor c;
         try
         {
            c = Class.forName(acceptorClass).getDeclaredConstructor(Utils.EMPTY_CLASSES);
            c.setAccessible(true);
            acceptor = (Acceptor) c.newInstance(Utils.EMPTY_OBJECTS);
         }
         catch (Exception e1)
         {
            log("Acceptor is not accessable or can't be instantiated, the Server is inoperable", e);
         }
      }
      catch (ClassNotFoundException e)
      {
         log("Acceptor class not found, the Server is inoperable", e);
      }
      Map acceptorProperties = new Properties();
      acceptor.init(arguments, acceptorProperties);
      hostName = (String) acceptorProperties.get(ARG_BINDADDRESS);
      return acceptor;
   }

   // Methods from ServletContext.

   // / Gets a servlet by name.
   // @param name the servlet name
   // @return null if the servlet does not exist

   public Servlet getServlet(String name)
   {
      try
      {
         return (Servlet) registry.get(name)[0];
      }
      catch (NullPointerException npe)
      {
         return null;
      }
   }

   // / Enumerates the servlets in this context (server). Only servlets that
   // are accesible will be returned. This enumeration always includes the
   // servlet itself.
   public Enumeration getServlets()
   {
      return registry.elements();
   }

   // / Enumerates the names of the servlets in this context (server). Only
   // servlets that are accesible will be returned. This enumeration always
   // includes the servlet itself.
   public Enumeration getServletNames()
   {
      return registry.keys();
   }

   // / Destroys all currently-loaded servlets.
   public synchronized void destroyAllServlets()
   {
      //log("Entering destroyAllServlets()", new Exception("Entering destroyAllServlets()"));
      // serialize sessions

      // invalidate all sessions
      // TODO consider merging two pieces below, generally if session is stored,
      // it shouldn't be invalidated
      File sf = getPersistentFile();
      if (sf != null && sessions != null)
      {
         Writer w = null;
         try
         {
            w = new FileWriter(sf);
            sessions.save(w);
            log("Sessions stored.");
         }
         catch (IOException ioe)
         {
            log("IO problem in storing sessions " + ioe);
         }
         catch (Throwable t)
         {
            log("Problem in storing sessions " + t);
         }
         finally
         {
            try
            {
               w.close();
            }
            catch (Exception e)
            {
            }
         }

         Enumeration e = sessions.keys();
         while (e.hasMoreElements())
         {
            Object sid = e.nextElement();
            if (sid != null)
            {
               AcmeSession as = (AcmeSession) sessions.get(sid);
               if (as != null)
               {
                  as = (AcmeSession) sessions.remove(sid);
                  if (as != null && as.isValid())
                     try
                     {
                        as.invalidate();
                     }
                     catch (IllegalStateException ise)
                     {

                     }
               }
            }
         }
      }
      // destroy servlets
      final Enumeration en = registry.elements();
      Runnable servletDestroyer = new Runnable()
      {
         public void run()
         {
            ((Servlet) en.nextElement()).destroy();
         }
      };
      int dhc = 0;
      while (en.hasMoreElements())
      {
         Thread destroyThread = new Thread(servletDestroyer, "Destroy");
         destroyThread.setDaemon(true);
         destroyThread.start();
         try
         {
            destroyThread.join(DESTROY_TIME_SEC * 1000);
         }
         catch (InterruptedException e)
         {
         }
         if (destroyThread.isAlive())
         {
            log("Destroy thread didn't terminate in " + DESTROY_TIME_SEC);
            destroyThread.setName("Destroy too long " + (dhc++)); // let it running with different name
            //destroyThread.stop();
         }
      }
      // clean access tree
      registry = new PathTreeDictionary();
   }

   protected void setMappingTable(PathTreeDictionary mappingtable)
   {
      this.mappingtable = mappingtable;
   }

   protected void setRealms(PathTreeDictionary realms)
   {
      this.realms = realms;
   }

   AcmeSession getSession(String id)
   {
      return (AcmeSession) sessions.get(id);
   }

   HttpSession createSession()
   {
      Integer ms = (Integer) this.arguments.get(ARG_MAX_ACTIVE_SESSIONS);
      if (ms != null && ms.intValue() < sessions.size())
         return null;
      HttpSession result = new AcmeSession(generateSessionId(), Math.abs(expiredIn) * 60, this, sessions);
      synchronized (sessions)
      {
         sessions.put(result.getId(), result);
      }
      return result;
   }

   void removeSession(String id)
   {
      synchronized (sessions)
      {
         sessions.remove(id);
      }
   }

   // / Write information to the servlet log.
   // @param message the message to log
   public void log(String message)
   {
      log.log(Level.INFO, message);
   }

   public void log(String message, Throwable throwable)
   {
      log.log(Level.SEVERE, message, throwable);
   }

   // protected void printCauses(Throwable throwable, PrintWriter printWriter) {
   // try {
   // throwable = throwable instanceof ServletException ? ((ServletException) throwable).getRootCause()
   // : (Throwable) throwable.getClass().getMethod("getCause", new Class[] {}).invoke(throwable,
   // new Object[] {});
   // if (throwable != null) {
   // printWriter.write("Caused by:\n");
   // throwable.printStackTrace(printWriter);
   // printCauses(throwable, printWriter);
   // }
   // } catch (Exception e) {
   // }
   // }

   // / Write a stack trace to the servlet log.
   // @param exception where to get the stack trace
   // @param message the message to log

   public void log(Exception exception, String message)
   {
      log(message, exception);
   }

   // / Applies alias rules to the specified virtual path and returns the
   // corresponding real path. It returns null if the translation
   // cannot be performed.
   // @param path the path to be translated
   public String getRealPath(String path)
   {
      // try {
      // path = new String(path.getBytes("ISO-8859-1"), UTF8);
      // } catch (Exception ee) { // no encoding
      // }
      // System.err.print("[" + path + "]->[");
      if (mappingtable != null)
      {
         // try find first sub-path
         Object[] os = mappingtable.get(path);
         // System.err.println("Searching for path: "+path+" found: "+os[0]);
         if (os[0] == null)
            return null;
         int slpos = ((Integer) os[1]).intValue();
         int pl = path.length();
         if (slpos > 0)
         {
            if (path.length() > slpos)
               path = path.substring(slpos + 1);
            else
               path = "";
         }
         else if (pl > 0)
         {
            for (int i = 0; i < pl; i++)
            {
               char s = path.charAt(i);
               if (s == '/' || s == '\\')
                  continue;
               else
               {
                  if (i > 0)
                     path = path.substring(i);
                  break;
               }
            }
         }
         // System.err.println("Path after processing :"+path+" slash was at
         // "+slpos);
         return new File((File) os[0], path).getPath();
      }
      return path;
   }

   /**
    * @return
    */
   public String getContextPath()
   {
      return "";
   }

   // / Returns the MIME type of the specified file.
   // @param file file name whose MIME type is required
   public String getMimeType(String file)
   {
      int dp = file.lastIndexOf('.');
      if (dp > 0)
      {
         return mime.getProperty(file.substring(dp + 1).toUpperCase());
      }
      return null;
   }

   // / Returns the name and version of the web server under which the servlet
   // is running.
   // Same as the CGI variable SERVER_SOFTWARE.
   public String getServerInfo()
   {
      return Serve.Identification.serverName + " " + Serve.Identification.serverVersion + " ("
              + Serve.Identification.serverUrl + ")";
   }

   // / Returns the value of the named attribute of the network service, or
   // null if the attribute does not exist. This method allows access to
   // additional information about the service, not already provided by
   // the other methods in this interface.
   public Object getAttribute(String name)
   {
      return attributes.get(name);
   }

   // ///////////////// JSDK 2.1 extensions //////////////////////////
   public void removeAttribute(String name)
   {
      attributes.remove(name);
   }

   public void setAttribute(String name, Object object)
   {
      if (object != null)
         attributes.put(name, object);
      else
         attributes.remove(name);
   }

   public Enumeration getAttributeNames()
   {
      return attributes.keys();
   }

   public ServletContext getContext(String uripath)
   {
      // TODO check webapp servlets to find out conexts for uri
      return this; // only root context supported
   }

   public int getMajorVersion()
   {
      return 2; // support 2.x
   }

   public int getMinorVersion()
   {
      return 5; // support 2.5
   }

   // 2.3

   /**
    * Returns a directory-like listing of all the paths to resources within the web application whose longest sub-path matches the supplied path argument.
    * Paths indicating subdirectory paths end with a '/'. The returned paths are all relative to the root of the web application and have a leading '/'. For
    * example, for a web application containing
    * <p/>
    * /welcome.html <br>
    * /catalog/index.html <br>
    * /catalog/products.html <br>
    * /catalog/offers/books.html <br>
    * /catalog/offers/music.html <br>
    * /customer/login.jsp <br>
    * /WEB-INF/web.xml <br>
    * /WEB-INF/classes/com.acme.OrderServlet.class,
    * <p/>
    * getResourcePaths("/") returns {"/welcome.html", "/catalog/", "/customer/", "/WEB-INF/"} <br>
    * getResourcePaths("/catalog/") returns {"/catalog/index.html", "/catalog/products.html", "/catalog/offers/"}.
    * <p/>
    *
    * @param the -
    *            partial path used to match the resources, which must start with a /
    * @return a Set containing the directory listing, or null if there are no resources in the web application whose path begins with the supplied path.
    * @since Servlet 2.3
    */
   public java.util.Set getResourcePaths(java.lang.String path)
   {
      String realPath = getRealPath(path);
      if (realPath != null)
      {

         String[] dir = new File(realPath).list();
         if (dir.length > 0)
         {
            HashSet set = new HashSet(dir.length);
            for (int i = 0; i < dir.length; i++)
               set.add(dir[i]);
            return set;
         }
      }
      return null;
   }

   /**
    * Returns the name of this web application correponding to this ServletContext as specified in the deployment descriptor for this web application by the
    * display-name element.
    *
    * @return The name of the web application or null if no name has been declared in the deployment descriptor.
    * @since Servlet 2.3
    */
   public java.lang.String getServletContextName()
   {
      return null;
   }

   /**
    * Returns a URL to the resource that is mapped to a specified path. The path must begin with a "/" and is interpreted as relative to the current context
    * root.
    * <p/>
    * <p/>
    * This method allows the servlet container to make a resource available to servlets from any source. Resources can be located on a local or remote file
    * system, in a database, or in a <code>.war</code> file.
    * <p/>
    * <p/>
    * The servlet container must implement the URL handlers and <code>URLConnection</code> objects that are necessary to access the resource.
    * <p/>
    * <p/>
    * This method returns <code>null</code> if no resource is mapped to the pathname.
    * <p/>
    * <p/>
    * Some containers may allow writing to the URL returned by this method using the methods of the URL class.
    * <p/>
    * <p/>
    * The resource content is returned directly, so be aware that requesting a <code>.jsp</code> page returns the JSP source code. Use a
    * <code>RequestDispatcher</code> instead to include results of an execution.
    * <p/>
    * <p/>
    * This method has a different purpose than <code>java.lang.Class.getResource</code>, which looks up resources based on a class loader. This method does
    * not use class loaders.
    *
    * @param path a <code>String</code> specifying the path to the resource
    * @return the resource located at the named path, or <code>null</code> if there is no resource at that path
    * @throws MalformedURLException if the pathname is not given in the correct form
    */
   public URL getResource(String path) throws MalformedURLException
   {
      if (path == null || path.length() == 0 || path.charAt(0) != '/')
         throw new MalformedURLException("Path " + path + " is not in acceptable form.");
      File resFile = new File(getRealPath(path));
      if (resFile.exists()) // TODO get canonical path is more robust
         return new URL("file", "localhost", resFile.getPath());
      return null;
   }

   /**
    * Returns the resource located at the named path as an <code>InputStream</code> object.
    * <p/>
    * <p/>
    * The data in the <code>InputStream</code> can be of any type or length. The path must be specified according to the rules given in
    * <code>getResource</code>. This method returns <code>null</code> if no resource exists at the specified path.
    * <p/>
    * <p/>
    * Meta-information such as content length and content type that is available via <code>getResource</code> method is lost when using this method.
    * <p/>
    * <p/>
    * The servlet container must implement the URL handlers and <code>URLConnection</code> objects necessary to access the resource.
    * <p/>
    * <p/>
    * This method is different from <code>java.lang.Class.getResourceAsStream</code>, which uses a class loader. This method allows servlet containers to
    * make a resource available to a servlet from any location, without using a class loader.
    *
    * @param path a <code>String</code> specifying the path to the resource
    * @return the <code>InputStream</code> returned to the servlet, or <code>null</code> if no resource exists at the specified path
    */
   public InputStream getResourceAsStream(String path)
   {
      try
      {
         return getResource(path).openStream();
      }
      catch (Exception e)
      {
      }
      return null;
   }

   public RequestDispatcher getRequestDispatcher(String urlpath)
   {
      if (urlpath == null || urlpath.length() == 0 || urlpath.charAt(0) != '/')
         return null;
      try
      {
         return new SimpleRequestDispatcher(urlpath);
      }
      catch (NullPointerException npe)
      {
         return null;
      }
   }

   // no way to specify parameters for context
   public String getInitParameter(String param)
   {
      return null;
   }

   public Enumeration getInitParameterNames()
   {
      return Utils.EMPTY_ENUMERATION;
   }

   public RequestDispatcher getNamedDispatcher(String name)
   {
      // named resources are not supported
      return null;
   }

   synchronized String generateSessionId()
   {
      srandom.nextBytes(uniqer);
      // TODO swap randomly bytes
      return Utils.base64Encode(uniqer);
   }

   protected class SimpleRequestDispatcher implements RequestDispatcher
   {
      HttpServlet servlet;

      String dispatchPath;

      String dispatchQuery;

      int dispatchLen;

      SimpleRequestDispatcher(String path)
      {
         Object[] os = registry.get(path);
         servlet = (HttpServlet) os[0];
         //log("Dispatch to: " + path + ", servlet "+servlet);
         if (servlet == null)
            throw new NullPointerException();
         dispatchLen = ((Integer) os[1]).intValue();
         int qmp = path.indexOf('?');
         if (qmp < 0 || qmp >= path.length() - 1)
            dispatchPath = path;
         else
         {
            dispatchPath = path.substring(0, qmp);
            dispatchQuery = path.substring(qmp + 1);
         }
      }

      public void forward(ServletRequest _request, ServletResponse _response) throws ServletException,
              java.io.IOException
      {
         _request.removeAttribute("javax.servlet.forward.request_uri"); // reset in case of nested
         _response.reset();
         servlet.service(new HttpServletRequestWrapper((HttpServletRequest) _request)
         {
            public java.lang.String getPathInfo()
            {
               return dispatchLen >= dispatchPath.length() ? null : dispatchPath.substring(dispatchLen);
            }

            public String getRequestURI()
            {
               return dispatchPath;
            }

            public String getQueryString()
            {
               return dispatchQuery;
            }

            public String getPathTranslated()
            {
               //System.out.println("Path t path i: "+getPathInfo()+", dp: "+dispatchPath);
               return getRequest().getRealPath(getPathInfo());
            }

            public String getServletPath()
            {
               return dispatchLen <= 0 ? "" : dispatchPath.substring(0, dispatchLen);
            }

            public synchronized java.util.Enumeration getAttributeNames()
            {
               if (super.getAttribute("javax.servlet.forward.request_uri") == null)
               {
                  setAttribute("javax.servlet.forward.request_uri", super.getRequestURI());
                  setAttribute("javax.servlet.forward.context_path", this.getContextPath());
                  setAttribute("javax.servlet.forward.servlet_path", super.getServletPath());
                  setAttribute("javax.servlet.forward.path_info", super.getPathInfo());
                  setAttribute("javax.servlet.forward.query_string", super.getQueryString());
               }
               return super.getAttributeNames();
            }

            public Object getAttribute(String name)
            {
               getAttributeNames(); // here is some overhead
               return super.getAttribute(name);
            }

         }, _response);
         // TODO think when response isn't actual response ServeConnection
         ((ServeConnection) _response).closeStreams(); // do not allow to continue
      }

      public void include(ServletRequest _request, ServletResponse _response) throws ServletException,
              java.io.IOException
      {
         _request.removeAttribute("javax.servlet.include.request_uri"); // reset in case of nested
         ((Serve.ServeConnection) _response).setInInclude(true);
         try
         {
            servlet.service(new HttpServletRequestWrapper((HttpServletRequest) _request)
            {
               public synchronized java.util.Enumeration getAttributeNames()
               {
                  if (super.getAttribute("javax.servlet.include.request_uri") == null)
                  {
                     setAttribute("javax.servlet.include.request_uri", dispatchPath);
                     setAttribute("javax.servlet.include.context_path", this.getContextPath());
                     setAttribute("javax.servlet.include.servlet_path", dispatchLen <= 0 ? "" : dispatchPath
                             .substring(0, dispatchLen));
                     setAttribute("javax.servlet.include.path_info", dispatchLen >= dispatchPath.length() ? null
                             : dispatchPath.substring(dispatchLen));
                     setAttribute("javax.servlet.include.query_string", dispatchQuery);
                  }
                  return super.getAttributeNames();
               }

               public Object getAttribute(String name)
               {
                  getAttributeNames(); // here is some overhead
                  return super.getAttribute(name);
               }

            }, _response);
         }
         finally
         {
            ((Serve.ServeConnection) _response).setInInclude(false);
         }
      }

   }

   // Keep Alive supporter, JDK 1.4 based for backwar compatibility
   class KeepAliveCleaner extends Thread
   {
      protected List connections;

      protected List ingoings;

      protected volatile boolean stopped;

      private boolean noCheckClose;

      KeepAliveCleaner()
      {
         super("KeepAlive cleaner");
         connections = new ArrayList();
         ingoings = new ArrayList();
         setDaemon(true);
      }

      public void end()
      {
         stopped = true;
         this.interrupt();
      }

      synchronized void addConnection(ServeConnection conn)
      {
         synchronized (ingoings)
         {
            if (stopped == false)
               ingoings.add(conn);
         }
      }

      public void run()
      {
         long d = getKeepAliveDuration();
         int maxUse = getMaxTimesConnectionUse();
         while (true)
         {
            synchronized (ingoings)
            {
               Iterator i = ingoings.iterator();
               while (i.hasNext())
               {
                  connections.add(i.next());
                  i.remove();
               }
            }
            Iterator i = connections.iterator();
            long ct = System.currentTimeMillis();
            d = getKeepAliveDuration();
            while (i.hasNext())
            {
               ServeConnection conn = (ServeConnection) i.next();
               boolean closed = conn.socket == null;
               if (noCheckClose == false)
                  synchronized (conn)
                  {
                     if (conn.socket != null)
                        try
                        {
                           closed = ((Boolean) conn.socket.getClass().getMethod("isClosed",
                                   Utils.EMPTY_CLASSES).invoke(conn.socket, Utils.EMPTY_OBJECTS))
                                   .booleanValue();
                        }
                        catch (IllegalArgumentException e)
                        {
                        }
                        catch (SecurityException e)
                        {
                        }
                        catch (IllegalAccessException e)
                        {
                        }
                        catch (InvocationTargetException e)
                        {
                        }
                        catch (NoSuchMethodException e)
                        {
                           noCheckClose = true;
                        }
                  }
               if (closed || (conn.keepAlive && (ct - conn.lastWait > d && conn.lastRun < conn.lastWait))
                       || stopped
                  /* || conn.timesRequested > maxUse */)
               {
                  i.remove();
                  synchronized (conn)
                  {
                     if (conn.socket != null)
                        try
                        {
                           //System.err.println("Closing socket:"+conn.socket.getClass().getName()); // !!!
                           //conn.socket.close();
                           conn.socket.getInputStream().close();
                        }
                        catch (IOException ioe)
                        {
                           // ignore
                        }
                     //System.err.println("done");
                  }
               }
            }
            if (stopped && connections.size() == 0)
               break;
            try
            {
               sleep(d);
            }
            catch (InterruptedException ie)
            {
               stopped = true; // not thread safe
            }
         }
      }
   }

   final static class Identification
   {
      public static final String serverName = "D. Rogatkin's TJWS based on Acme.Serve";

      public static final String serverVersion = "Version 1.70, $Revision: 1.194 $";

      public static final String serverUrl = "http://tjws.sourceforge.net";

      public static final String serverIdHtml = "<ADDRESS><A HREF=\"" + serverUrl + "\">" + serverName + " " + serverVersion + "</A></ADDRESS>";
   }

   // ////////////////////////////////////////////////////////////////

   protected static class ServeConfig implements ServletConfig
   {

      private ServletContext context;

      private Hashtable init_params;

      private String servletName;

      public ServeConfig(ServletContext context)
      {
         this(context, null, "undefined");
      }

      public ServeConfig(ServletContext context, Hashtable initParams, String servletName)
      {
         this.context = context;
         this.init_params = initParams;
         this.servletName = servletName;
      }

      // Methods from ServletConfig.

      // / Returns the context for the servlet.

      public ServletContext getServletContext()
      {
         return context;
      }

      // / Gets an initialization parameter of the servlet.
      // @param name the parameter name
      public String getInitParameter(String name)
      {
         // This server supports servlet init params. :)
         if (init_params != null)
            return (String) init_params.get(name);
         return null;
      }

      // / Gets the names of the initialization parameters of the servlet.
      // @param name the parameter name
      public Enumeration getInitParameterNames()
      {
         // This server does:) support servlet init params.
         if (init_params != null)
            return init_params.keys();
         return new Vector().elements();
      }

      // 2.2
      public String getServletName()
      {
         return servletName;
      }
   }

   // /////////////////////////////////////////////////////////////////////
   /**
    * provides request/response
    */
   public static class ServeConnection implements Runnable, HttpServletRequest, HttpServletResponse
   {
      private Socket socket;

      private Hashtable sslAttributes;

      private Serve serve;

      private ServletInputStream in;

      private ServletOutputStream out;

      private String scheme;

      public final static String WWWFORMURLENCODE = "application/x-www-form-urlencoded";

      public final static String TRANSFERENCODING = "transfer-encoding".toLowerCase();

      public final static String KEEPALIVE = "Keep-Alive".toLowerCase();

      public final static String CONTENT_ENCODING = "Content-Encoding".toLowerCase();

      public final static String CONNECTION = "Connection".toLowerCase();

      public final static String CHUNKED = "chunked";

      public final static String CONTENTLENGTH = "Content-Length".toLowerCase();

      public final static String CONTENTTYPE = "Content-Type".toLowerCase();

      public final static String SETCOOKIE = "Set-Cookie".toLowerCase();

      public final static String HOST = "Host".toLowerCase();

      public final static String COOKIE = "Cookie".toLowerCase();

      public final static String ACCEPT_LANGUAGE = "Accept-Language".toLowerCase();

      public final static String SESSION_COOKIE_NAME = "JSESSIONID";

      public final static String SESSION_URL_NAME = ";$sessionid$"; // ;jsessionid=

      private static final Map EMPTYHASHTABLE = new Hashtable();

      // URL rewriting
      // http://www.myserver.com/catalog/index.html;jsessionid=mysession1928
      // like:
      // http://www.sun.com/2001-0227/sunblade/;$sessionid$AD5RQ0IAADJAZAMTA1LU5YQ

      private String reqMethod; // == null by default

      private String reqUriPath, reqUriPathUn;

      private String reqProtocol;

      private String charEncoding; // req and resp

      private String remoteUser;

      private String authType;

      private boolean oneOne; // HTTP/1.1 or better

      private boolean reqMime;

      private Vector reqHeaderNames = new Vector();

      private Vector reqHeaderValues = new Vector();

      private Locale locale; // = java.util.Locale.getDefault();

      private int uriLen;

      protected boolean keepAlive = true;

      protected int timesRequested;

      protected long lastRun, lastWait;

      private Vector outCookies;

      private Vector inCookies;

      private String sessionCookieValue, sessionUrlValue, sessionValue;

      protected String reqQuery;

      private PrintWriter pw;

      private ServletOutputStream rout;

      private Map formParameters;

      private Hashtable attributes = new Hashtable();

      private int resCode = -1;

      private String resMessage;

      private Hashtable resHeaderNames = new Hashtable();

      private String[] postCache;

      private boolean headersWritten;

      private MessageFormat accessFmt;

      private Object[] logPlaceholders;

      // TODO consider creation an instance per thread in a pool, thread memory can be used

      private final SimpleDateFormat expdatefmt = new SimpleDateFormat("EEE, dd-MMM-yyyy HH:mm:ss 'GMT'", Locale.US); // used for cookie

      private final SimpleDateFormat rfc850DateFmt = new SimpleDateFormat("EEEEEE, dd-MMM-yy HH:mm:ss 'GMT'",
              Locale.US); // rfc850-date

      private final SimpleDateFormat headerdateformat = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss 'GMT'",
              Locale.US); // rfc1123-date

      private final SimpleDateFormat asciiDateFmt = new SimpleDateFormat("EEE MMM d HH:mm:ss yyyy", Locale.US); // ASCII date, used in headers

      private static final TimeZone tz = TimeZone.getTimeZone("GMT");

      static
      {
         tz.setID("GMT");
      }

      /*
         * protected void finalize() throws Throwable { serve.log("Connection collected"); super.finalize(); }
         */

      // / Constructor.

      public ServeConnection(Socket socket, Serve serve)
      {
         // Save arguments.
         this.socket = socket;
         this.serve = serve;
         expdatefmt.setTimeZone(tz);
         headerdateformat.setTimeZone(tz);
         rfc850DateFmt.setTimeZone(tz);
         asciiDateFmt.setTimeZone(tz);
         if (serve.isAccessLogged())
         {
            // not format string must be not tull
            accessFmt = new MessageFormat((String) serve.arguments.get(ARG_ACCESS_LOG_FMT));
            logPlaceholders = new Object[12];
         }
         serve.threadPool.executeThread(this);
         synchronized(serve.connections)
         {
            serve.connections.add(this);
         }
      }

      private void initSSLAttrs()
      {
         if (socket.getClass().getName().indexOf("SSLSocket") > 0)
         {
            try
            {
               sslAttributes = new Hashtable();
               Object sslSession = socket.getClass().getMethod("getSession", Utils.EMPTY_CLASSES).invoke(socket,
                       Utils.EMPTY_OBJECTS);
               if (sslSession != null)
               {
                  sslAttributes.put("javax.net.ssl.session", sslSession);
                  Method m = sslSession.getClass().getMethod("getCipherSuite", Utils.EMPTY_CLASSES);
                  m.setAccessible(true);
                  sslAttributes.put("javax.net.ssl.cipher_suite", m.invoke(sslSession, Utils.EMPTY_OBJECTS));
                  m = sslSession.getClass().getMethod("getPeerCertificates", Utils.EMPTY_CLASSES);
                  m.setAccessible(true);
                  sslAttributes.put("javax.net.ssl.peer_certificates", m.invoke(sslSession, Utils.EMPTY_OBJECTS));
               }
            }
            catch (IllegalAccessException iae)
            {
               sslAttributes = null;
               //iae.printStackTrace();
            }
            catch (NoSuchMethodException nsme)
            {
               sslAttributes = null;
               //nsme.printStackTrace();
            }
            catch (InvocationTargetException ite)
            {
               // note we do not clear attributes, because SSLPeerUnverifiedException
               // happens in the last call, when no client sertificate
               //sslAttributes = null;
               //ite.printStackTrace();
            }
            catch (IllegalArgumentException iae)
            {
               //sslAttributes = null;
               //iae.printStackTrace();
            }
            //System.err.println("Socket SSL attrs: "+sslAttributes);
         }
      }

      /**
       * it closes stream awaring of keep -alive
       *
       * @throws IOException
       */
      public void closeStreams() throws IOException
      {
         //System.err.println("===>CLOSE()");
         IOException ioe = null;
         try
         {
            if (pw != null)
               pw.flush();
            else
               out.flush();
         }
         catch (IOException io1)
         {
            ioe = io1;
         }
         try
         {
            out.close();
         }
         catch (IOException io1)
         {
            if (ioe != null)
               ioe = (IOException) ioe.initCause(io1);
            else
               ioe = io1;
         }
         try
         {
            in.close();
         }
         catch (IOException io1)
         {
            if (ioe != null)
               ioe = (IOException) ioe.initCause(io1);
            else
               ioe = io1;
         }
         if (ioe != null)
            throw ioe;
      }

      public void closeSocket()
      {
         if (socket != null)
         {
            try
            {
               socket.close();
            }
            catch (IOException e)
            {
            }
         }
      }

      // protected void finalize() throws Throwable {
      // System.err.println("Connection object gone"); // !!!
      // super.finalize();
      // }

      private void restart()
      {
         // new Exception("RESTART").printStackTrace();
         reqMethod = null;
         reqUriPath = reqUriPathUn = null;
         reqProtocol = null;
         charEncoding = null;
         remoteUser = null;
         authType = null;
         oneOne = false;
         reqMime = false;
         // considering that clear() works faster than new
         if (reqHeaderNames == null)
            reqHeaderNames = new Vector();
         else
            reqHeaderNames.clear();
         if (reqHeaderValues == null)
            reqHeaderValues = new Vector();
         else
            reqHeaderValues.clear();
         locale = null;
         uriLen = 0;
         outCookies = null;
         inCookies = null;
         sessionCookieValue = null;
         sessionUrlValue = null;
         sessionValue = null;
         reqQuery = null;
         pw = null;
         rout = null;
         formParameters = null;
         if (attributes == null)
            attributes = new Hashtable();
         else
            attributes.clear();
         if (sslAttributes != null)
            attributes.putAll(sslAttributes);
         resCode = -1;
         resMessage = null;
         resHeaderNames.clear();
         headersWritten = false;
         postCache = null;
         ((ServeInputStream) in).refresh();
         ((ServeOutputStream) out).refresh();
      }

      // Methods from Runnable.
      public void run()
      {
         try
         {
            initSSLAttrs();
            in = new ServeInputStream(socket.getInputStream(), this);
            out = new ServeOutputStream(socket.getOutputStream(), this);
            do
            {
               restart();
               // Get the streams.
               parseRequest();
               if (reqMethod != null && serve.isAccessLogged() && serve.log.isLoggable(Level.FINER))
               {
                  // consider caching socket stuff for faster logging
                  // {0} {1} {2} [{3,date,dd/MMM/yyyy:HH:mm:ss Z}] \"{4} {5} {6}\" {7,number,#} {8,number} {9} {10}
                  // ARG_ACCESS_LOG_FMT
                  logPlaceholders[0] = socket.getInetAddress(); // IP
                  logPlaceholders[1] = "-"; // the RFC 1413 identity of the client
                  logPlaceholders[2] = remoteUser == null ? "-" : remoteUser; // remote user
                  logPlaceholders[3] = new Date(lastRun); // time stamp {3,date,dd/MMM/yyyy:HH:mm:ss Z} {3,time,}
                  logPlaceholders[4] = reqMethod; // method
                  logPlaceholders[5] = reqUriPathUn; // resource
                  logPlaceholders[6] = reqProtocol; // protocol
                  logPlaceholders[7] = new Integer(resCode); // res code
                  logPlaceholders[8] = new Long(((ServeOutputStream) out).lengthWritten());
                  logPlaceholders[9] = new Integer(socket.getLocalPort());
                  logPlaceholders[10] = serve.isShowReferer() ? getHeader("Referer") : "-";
                  logPlaceholders[11] = serve.isShowUserAgent() ? getHeader("User-Agent") : "-";
                  serve.log.finer(accessFmt.format(logPlaceholders));
               }
               lastRun = 0;
               timesRequested++;
            } while (keepAlive && serve.isKeepAlive() && timesRequested < serve.getMaxTimesConnectionUse());
         }
         catch (IOException ioe)
         {
            //System.err.println("Drop "+ioe);
            String errMsg = ioe.getMessage();
            if ((errMsg == null || errMsg.indexOf("ocket closed") < 0) && ioe instanceof java.nio.channels.AsynchronousCloseException == false)
               serve.log("IO error: " + ioe + " in processing a request from " + socket.getInetAddress() + ":"
                       + socket.getLocalPort() + " / " + socket.getClass().getName()/*, ioe*/);
            else
               synchronized (this)
               {
                  //serve.log("Exception considered as socket closed:"+ioe, ioe);
                  socket = null;
               }
         }
         finally
         {
            synchronized (this)
            {
               synchronized(serve.connections)
               {
                  serve.connections.remove(this);
               }
               if (socket != null)
                  try
                  {
                     socket.close();
                  }
                  catch (IOException e)
                  { /* ignore */
                  }
               socket = null;
            }
         }
      }

      private void parseRequest() throws IOException
      {
         byte[] lineBytes = new byte[4096];
         int len;
         String line;
         // / TODO put time mark here for start waiting for receiving requests
         lastWait = System.currentTimeMillis();
         // Read the first line of the request.
         len = in.readLine(lineBytes, 0, lineBytes.length);
         if (len == -1 || len == 0)
         {
            if (keepAlive)
            {
               keepAlive = false;
               // connection seems be closed

            }
            else
            {
               problem("Status-Code 400: Bad Request(empty)", SC_BAD_REQUEST);
            }
            return;
         }
         if (len >= lineBytes.length)
         {
            problem("Status-Code 414: Request-URI Too Long", SC_REQUEST_URI_TOO_LONG);
            return;
         }
         // //lastRun = 0; // to avoid closing socket in long process
         line = new String(lineBytes, 0, len, UTF8);
         StringTokenizer ust = new StringTokenizer(line);
         if (ust.hasMoreTokens())
         {
            reqMethod = ust.nextToken();
            if (ust.hasMoreTokens())
            {
               reqUriPathUn = ust.nextToken();
               // TODO make it only when URL overwrite enambled
               int uop = reqUriPathUn.indexOf(SESSION_URL_NAME);
               if (uop > 0)
               {
                  sessionUrlValue = reqUriPathUn.substring(uop + SESSION_URL_NAME.length());
                  reqUriPathUn = reqUriPathUn.substring(0, uop);
                  try
                  {
                     serve.getSession(sessionUrlValue).userTouch();
                  }
                  catch (NullPointerException npe)
                  {
                     sessionUrlValue = null;
                  }
                  catch (IllegalStateException ise)
                  {
                     sessionUrlValue = null;
                  }
               }
               if (ust.hasMoreTokens())
               {
                  reqProtocol = ust.nextToken();
                  oneOne = !reqProtocol.toUpperCase().equals("HTTP/1.0");
                  reqMime = true;
                  // Read the rest of the lines.
                  String s;
                  while ((s = ((ServeInputStream) in).readLine(HTTP_MAX_HDR_LEN)) != null)
                  {
                     if (s.length() == 0)
                        break;
                     int c = s.indexOf(':', 0);
                     if (c > 0)
                     {
                        String key = s.substring(0, c).trim().toLowerCase();
                        String value = s.substring(c + 1).trim();
                        reqHeaderNames.addElement(key);
                        reqHeaderValues.addElement(value);
                        if (CONNECTION.equalsIgnoreCase(key))
                           if (oneOne)
                              keepAlive = "close".equalsIgnoreCase(value) == false;
                           else
                              keepAlive = KEEPALIVE.equalsIgnoreCase(value);
                        else if (KEEPALIVE.equalsIgnoreCase(key))
                        { /// FF specific ?
                           // parse value to extract the connection specific timeoutKeepAlive and maxAliveConnUse
                           // todo that introduce the value in req/resp and copy defaults from Serve

                        }
                     }
                     else
                        serve.log("header field '" + s + "' without ':'");
                  }
               }
               else
               {
                  reqProtocol = "HTTP/0.9";
                  oneOne = false;
                  reqMime = false;
               }
            }
         }

         if (reqProtocol == null)
         {
            problem("Status-Code 400: Malformed request line:" + line, SC_BAD_REQUEST);
            return;
         }
         // Check Host: header in HTTP/1.1 requests.
         if (oneOne)
         {
            String host = getHeader(HOST);
            if (host == null)
            {
               problem("'Host' header missing in HTTP/1.1 request", SC_BAD_REQUEST);
               return;
            }
         }

         // Split off query string, if any.
         int qmark = reqUriPathUn.indexOf('?');
         if (qmark > -1)
         {
            if (qmark < reqUriPathUn.length() - 1)
               reqQuery = reqUriPathUn.substring(qmark + 1);
            reqUriPathUn = reqUriPathUn.substring(0, qmark);
         }
         reqUriPath = Utils.decode(reqUriPathUn, UTF8);
         // TDOD check if reqUriPathUn starts with http://host:port
         if (CHUNKED.equals(getHeader(TRANSFERENCODING)))
         {
            setHeader(CONTENTLENGTH, null);
            ((ServeInputStream) in).chunking(true);
         }
         String contentEncoding = extractEncodingFromContentType(getHeader(CONTENTTYPE));
         // TODO: encoding in request can be invalid, then do default
         setCharacterEncoding(contentEncoding != null ? contentEncoding : UTF8);
         String contentLength = getHeader(CONTENTLENGTH);
         if (contentLength != null)
            try
            {
               ((ServeInputStream) in).setContentLength(Long.parseLong(contentLength));
            }
            catch (NumberFormatException nfe)
            {
               serve.log("Invalid value of input content-length: " + contentLength);
            }
         // the code was originally in processing headers loop, however hhas been moved here
         String encoding = getHeader(CONTENT_ENCODING);
         /*  Don't do content encoding.  Let RESTEASY handle it
         if (encoding != null)
         {
            if ((encoding.equalsIgnoreCase("gzip") || encoding.equalsIgnoreCase("compressed"))
                    && null != serve.gzipInStreamConstr && ((ServeInputStream) in).compressed(true))
            {
            }
            else
            {
               problem("Status-Code 415: Unsupported media type:" + encoding, SC_UNSUPPORTED_MEDIA_TYPE);
               return;
            }
         }
         */
         if (assureHeaders() && socket.getKeepAlive() == false)
            socket.setKeepAlive(true);
         // TODO new SimpleRequestDispatcher(reqUriPathUn).forward((ServletRequest) this, (ServletResponse) this);
         Object[] os = serve.registry.get(reqUriPath);
         if (os[0] != null)
         { // note, os always not null
            // / TODO put time mark here to monitor actual servicing
            lastRun = System.currentTimeMillis();
            // System.err.println("Servlet "+os[0]+" for path "+reqUriPath);
            uriLen = ((Integer) os[1]).intValue();
            runServlet((HttpServlet) os[0]);
         }
         else
         {
            problem("No any servlet found for serving " + reqUriPath, SC_BAD_REQUEST);
         }
      }

      private boolean assureHeaders()
      {
         if (reqMime)
            setHeader("MIME-Version", "1.0");
         setDateHeader("Date", System.currentTimeMillis());
         setHeader("Server", Serve.Identification.serverName + "/" + Serve.Identification.serverVersion);
         if (keepAlive && serve.isKeepAlive())
         {
            if (reqMime)
            {
               setHeader(CONNECTION, KEEPALIVE); // set for 1.1 too, because some client do not follow a standard
               if (oneOne)
                  setHeader(KEEPALIVE, serve.getKeepAliveParamStr());
            }
            return true;
         }
         else
            setHeader(CONNECTION, "close");
         return false;
      }

      private void runServlet(HttpServlet servlete) throws IOException
      {
         // Set default response fields.
         setStatus(SC_OK);
         try
         {
            parseCookies();
            if (sessionValue == null) // not from cookie
               sessionValue = sessionUrlValue;
            if (authenificate())
            {
               if (servlete instanceof SingleThreadModel)
                  synchronized (servlete)
                  {
                     servlete.service((ServletRequest) this, (ServletResponse) this);
                  }
               else
                  servlete.service((ServletRequest) this, (ServletResponse) this);
            }
            // old close
         }
         catch (UnavailableException e)
         {
            if (e.isPermanent())
            {
               serve.registry.remove(servlete);
               servlete.destroy();
            }
            else if (e.getUnavailableSeconds() > 0)
               serve.log("Temporary unavailability feature is not supported " + servlete);
            problem(e.getMessage(), SC_SERVICE_UNAVAILABLE);
         }
         catch (ServletException e)
         {
            serve.log("Servlet exception", e);
            Throwable rootCause = e.getRootCause();
            while (rootCause != null)
            {
               serve.log("Caused by", rootCause);
               if (rootCause instanceof ServletException)
                  rootCause = ((ServletException) rootCause).getRootCause();
               else
                  rootCause = rootCause.getCause(); /* 1.4 */
            }
            problem(e.toString(), SC_INTERNAL_SERVER_ERROR);
         }
         catch (IOException ioe)
         {
            throw ioe;
         }
         catch (Exception e)
         {
            serve.log("Unexpected problem running servlet", e);
            problem("Unexpected problem running servlet: " + e.toString(), SC_INTERNAL_SERVER_ERROR);
         }
         finally
         {
            closeStreams();
            // socket will be closed by a caller if no keep-alive
         }
      }

      private boolean authenificate() throws IOException
      {
         Object[] o = serve.realms.get(reqUriPath); // by Niel Markwick
         BasicAuthRealm realm = null;
         if (o != null)
            realm = (BasicAuthRealm) o[0];
         // System.err.println("looking for realm for path "+getPathInfo()+"
         // in
         // "+serve.realms+" found "+realm);
         if (realm == null)
            return true;

         String credentials = getHeader("Authorization");

         if (credentials != null)
         {
            credentials = Acme.Utils.base64Decode(credentials.substring(credentials.indexOf(' ') + 1),
                    getCharacterEncoding());
            int i = credentials.indexOf(':');
            String user = credentials.substring(0, i);
            String password = credentials.substring(i + 1);
            remoteUser = user;
            authType = "BASIC"; // support only basic authenification (FORM, CLIENT_CERT, DIGEST )
            String realPassword = (String) realm.get(user);
            // System.err.println("User "+user+" Password "+password+" real
            // "+realPassword);
            if (realPassword != null && realPassword.equals(password))
               return true;
         }

         setStatus(SC_UNAUTHORIZED);
         setHeader("WWW-Authenticate", "basic realm=\"" + realm.name() + '"');
         //writeHeaders(); // because sendError() is used
         realSendError();
         return false;
      }

      private void problem(String logMessage, int resCode)
      {
         serve.log(logMessage);
         try
         {
            sendError(resCode, logMessage);
         }
         catch (IllegalStateException e)
         { /* ignore */
         }
         catch (IOException e)
         { /* ignore */
         }
      }

      private static final int MAYBEVERSION = 1;

      private static final int INVERSION = 2;

      private static final int OLD_INNAME = 3;

      private static final int OLD_INVAL = 4;

      private static final int INVERSIONNUM = 5;

      private static final int RECOVER = 6;

      private static final int NEW_INNAME = 7;

      private static final int NEW_INVAL = 8;

      private static final int INPATH = 9;

      private static final int MAYBEINPATH = 10;

      private static final int INPATHVALUE = 11;

      private static final int MAYBEPORT = 12;

      private static final int INDOMAIN = 13;

      private static final int MAYBEDOMAIN = 14;

      private static final int INPORT = 15;

      private static final int INDOMAINVALUE = 16;

      private static final int INPORTVALUE = 17;

      private void parseCookies() throws IOException
      {
         if (inCookies == null)
            inCookies = new Vector();
         String cookies = getHeader(COOKIE);
         if (cookies == null)
            return;
         try
         {
            String cookie_name = null;
            String cookie_value = null;
            String cookie_path = null;
            String cookie_domain = null;
            if (cookies.length() > 300 * 4096)
               throw new IOException("Cookie string too long:" + cookies.length());
            //System.err.println("We received:" + cookies);
            char[] cookiesChars = cookies.toCharArray();
            int state = MAYBEVERSION;
            StringBuffer token = new StringBuffer(256);
            boolean quoted = false;
            for (int i = 0; i < cookiesChars.length; i++)
            {
               char c = cookiesChars[i];

               switch (state)
               {
                  case MAYBEVERSION:
                     if (c != ' ')
                     {
                        token.append(c);
                        if (c == '$')
                        {
                           state = INVERSION; // RFC 2965
                        }
                        else
                           // RFC 2109
                           state = OLD_INNAME;
                     }
                     break;
                  case OLD_INNAME:
                     if (c == '=')
                     {
                        state = OLD_INVAL;
                        cookie_name = token.toString();
                        token.setLength(0);
                     }
                     else if (c != ' ' || token.length() > 0)
                        token.append(c);
                     break;
                  // TODO introduce val_start. then quoted value and value
                  case OLD_INVAL:
                     if (quoted == false)
                     {
                        if (c == ';')
                        {
                           state = OLD_INNAME;
                           cookie_value = token.toString();
                           token.setLength(0);
                           addCookie(cookie_name, cookie_value, null, null);
                        }
                        else if (c == '"' && token.length() == 0)
                           quoted = true;
                        else
                           token.append(c);
                     }
                     else
                     {
                        if (c == '"')
                           quoted = false;
                        else
                           token.append(c);
                     }
                     break;
                  case INVERSION:
                     if (c == '=')
                     {
                        if ("$Version".equals(token.toString()))
                           state = INVERSIONNUM;
                        else
                        {
                           state = OLD_INVAL; // consider name starts with $
                           cookie_name = token.toString();
                        }
                        token.setLength(0);
                     }
                     else
                        token.append(c);
                     break;
                  case INVERSIONNUM:
                     if (c == ',' || c == ';')
                     {
                        token.setLength(0);
                        state = NEW_INNAME;
                     }
                     else if (Character.isDigit(c) == false)
                     {
                        state = RECOVER;
                     }
                     else
                        token.append(c);
                     break;
                  case NEW_INNAME:
                     if (c == '=')
                     {
                        state = NEW_INVAL;
                        cookie_name = token.toString();
                        token.setLength(0);
                     }
                     else if (c != ' ' || token.length() > 0)
                        token.append(c);
                     break;
                  case NEW_INVAL:
                     if (c == ';')
                     {
                        state = MAYBEINPATH;
                        cookie_value = token.toString();
                        token.setLength(0);
                        cookie_path = null;
                     }
                     else if (c == ',')
                     {
                        state = NEW_INNAME;
                        cookie_value = token.toString();
                        token.setLength(0);
                        addCookie(cookie_name, cookie_value, null, null);
                     }
                     else
                        token.append(c);
                     break;
                  case MAYBEINPATH:
                     if (c != ' ')
                     {
                        token.append(c);
                        if (c == '$')
                        {
                           state = INPATH;
                        }
                        else
                        {
                           addCookie(cookie_name, cookie_value, null, null);
                           state = NEW_INNAME;
                        }
                     }
                     break;
                  case INPATH:
                     if (c == '=')
                     {
                        if ("$Path".equals(token.toString()))
                           state = INPATHVALUE;
                        else
                        {
                           addCookie(cookie_name, cookie_value, null, null);
                           state = NEW_INVAL; // consider name starts with $
                           cookie_name = token.toString();
                        }
                        token.setLength(0);
                     }
                     else
                        token.append(c);
                     break;
                  case INPATHVALUE:
                     if (c == ',')
                     {
                        cookie_path = token.toString();
                        state = NEW_INNAME;
                        addCookie(cookie_name, cookie_value, cookie_path, null);
                        token.setLength(0);
                     }
                     else if (c == ';')
                     {
                        state = MAYBEDOMAIN;
                        cookie_path = token.toString();
                        token.setLength(0);
                     }
                     else
                        token.append(c);
                     break;
                  case MAYBEDOMAIN:
                     if (c != ' ')
                     {
                        token.append(c);
                        if (c == '$')
                        {
                           state = INDOMAIN;
                        }
                        else
                        {
                           addCookie(cookie_name, cookie_value, cookie_path, null);
                           state = NEW_INNAME;
                        }
                     }
                     break;
                  case INDOMAIN:
                     if (c == '=')
                     {
                        if ("$Domain".equals(token.toString()))
                           state = INDOMAINVALUE;
                        else
                        {
                           addCookie(cookie_name, cookie_value, cookie_path, null);
                           state = NEW_INVAL; // consider name starts with $
                           cookie_name = token.toString();
                        }
                        token.setLength(0);
                     }
                     break;
                  case INDOMAINVALUE:
                     if (c == ',')
                     {
                        state = NEW_INNAME;
                        addCookie(cookie_name, cookie_value, cookie_path, token.toString());
                        token.setLength(0);
                     }
                     else if (c == ';')
                     {
                        cookie_domain = token.toString();
                        state = MAYBEPORT;
                     }
                     else
                        token.append(c);
                     break;
                  case MAYBEPORT:
                     if (c != ' ')
                     {
                        token.append(c);
                        if (c == '$')
                        {
                           state = INPORT;
                        }
                        else
                        {
                           addCookie(cookie_name, cookie_value, cookie_path, cookie_domain);
                           state = NEW_INNAME;
                        }
                     }
                     break;
                  case INPORT:
                     if (c == '=')
                     {
                        if ("$Port".equals(token.toString()))
                           state = INPORTVALUE;
                        else
                        {
                           addCookie(cookie_name, cookie_value, cookie_path, cookie_domain);
                           state = NEW_INVAL; // consider name starts with $
                           cookie_name = token.toString();
                        }
                        token.setLength(0);
                     }
                     break;
                  case INPORTVALUE:
                     if (c == ',' || c == ';')
                     {
                        int port = Integer.parseInt(token.toString());
                        state = NEW_INNAME;
                        addCookie(cookie_name, cookie_value, cookie_path, cookie_domain);
                        token.setLength(0);
                     }
                     else if (Character.isDigit(c) == false)
                     {
                        state = RECOVER;
                     }
                     else
                        token.append(c);
                     break;
                  case RECOVER:
                     serve.log("Parsing recover of cookie string " + cookies, null);
                     if (c == ';' || c == ',')
                     {
                        token.setLength(0);
                        state = NEW_INNAME;
                     }
                     break;
               }
            }
            if (state == OLD_INVAL || state == NEW_INVAL)
            {
               cookie_value = token.toString();
               addCookie(cookie_name, cookie_value, null, null);
            }
            else if (state == INPATHVALUE)
            {
               addCookie(cookie_name, cookie_value, token.toString(), null);
            }
            else if (state == INDOMAINVALUE)
            {
               addCookie(cookie_name, cookie_value, cookie_path, token.toString());
            }
            else if (state == INPORTVALUE)
               addCookie(cookie_name, cookie_value, cookie_path, cookie_domain);
         }
         catch (Error e)
         {
            serve.log("Error in parsing cookies: " + cookies, e);
         }
         catch (Exception e)
         {
            serve.log("An exception in parsing cookies: " + cookies, e);
         }
      }

      private void addCookie(String name, String value, String path, String domain)
      {
         if (SESSION_COOKIE_NAME.equals(name) && sessionCookieValue == null)
         {
            sessionCookieValue = value;
            try
            {
               serve.getSession(sessionCookieValue).userTouch();
               sessionValue = sessionCookieValue;
               sessionUrlValue = null;
            }
            catch (IllegalStateException ise)
            {
               sessionCookieValue = null;
            }
            catch (NullPointerException npe)
            {
               sessionCookieValue = null;
            }
         }
         else
         {
            Cookie c;
            inCookies.addElement(c = new Cookie(name, value));
            if (path != null)
            {
               c.setPath(path);
               if (domain != null)
                  c.setDomain(domain);
            }
         }
      }

      // Methods from ServletRequest.

      // / Returns the size of the request entity data, or -1 if not known.
      // Same as the CGI variable CONTENT_LENGTH.

      public int getContentLength()
      {
         return getIntHeader(CONTENTLENGTH);
      }

      // / Returns the MIME type of the request entity data, or null if
      // not known.
      // Same as the CGI variable CONTENT_TYPE.
      public String getContentType()
      {
         return getHeader(CONTENTTYPE);
      }

      // / Returns the protocol and version of the request as a string of
      // the form <protocol>/<major version>.<minor version>.
      // Same as the CGI variable SERVER_PROTOCOL.
      public String getProtocol()
      {
         return reqProtocol;
      }

      // / Returns the scheme of the URL used in this request, for example
      // "http", "https", or "ftp". Different schemes have different rules
      // for constructing URLs, as noted in RFC 1738. The URL used to create
      // a request may be reconstructed using this scheme, the server name
      // and port, and additional information such as URIs.
      public String getScheme()
      {
         if (scheme == null)
            // lazy stuf dlc
            synchronized (this)
            {
               if (scheme == null)
                  scheme = socket.getClass().getName().indexOf("SSLSocket") > 0 ? "https" : "http";
            }
         return scheme;
      }

      // / Returns the host name of the server as used in the <host> part of
      // the request URI.
      // Same as the CGI variable SERVER_NAME.
      public String getServerName()
      {
         String serverName;
         serverName = getHeader(HOST);
         if (serverName != null && serverName.length() > 0)
         {
            int colon = serverName.indexOf(':');
            if (colon >= 0)
            {
               if (colon < serverName.length())
                  serverName = serverName.substring(0, colon);
            }
         }

         if (serverName == null)
         {
            try
            {
               serverName = InetAddress.getLocalHost().getHostName();
            }
            catch (java.net.UnknownHostException ignore)
            {
               serverName = "127.0.0.0";
            }
         }

         int slash = serverName.indexOf("/");
         if (slash >= 0)
            serverName = serverName.substring(slash + 1);
         return serverName;
      }

      // / Returns the port number on which this request was received as used
      // in
      // the <port> part of the request URI.
      // Same as the CGI variable SERVER_PORT.
      public int getServerPort()
      {
         return socket.getLocalPort();
      }

      // / Returns the IP address of the agent that sent the request.
      // Same as the CGI variable REMOTE_ADDR.
      public String getRemoteAddr()
      {
         return socket.getInetAddress().getHostAddress();
      }

      // / Returns the fully qualified host name of the agent that sent the
      // request.
      // Same as the CGI variable REMOTE_HOST.
      public String getRemoteHost()
      {
         String result = socket.getInetAddress().getHostName();
         return result != null ? result : getRemoteAddr();
      }

      // / Applies alias rules to the specified virtual path and returns the
      // corresponding real path, or null if the translation can not be
      // performed for any reason. For example, an HTTP servlet would
      // resolve the path using the virtual docroot, if virtual hosting is
      // enabled, and with the default docroot otherwise. Calling this
      // method with the string "/" as an argument returns the document root.
      public String getRealPath(String path)
      {
         return serve.getRealPath(path);
      }

      // / Returns an input stream for reading request data.
      // @exception IllegalStateException if getReader has already been called
      // @exception IOException on other I/O-related errors
      public ServletInputStream getInputStream() throws IOException
      {
         synchronized (in)
         {
            if (((ServeInputStream) in).isReturnedAsReader())
               throw new IllegalStateException("Already returned as a reader.");
            ((ServeInputStream) in).setReturnedAsStream(true);
         }
         return in;
      }

      // / Returns a buffered reader for reading request data.
      // @exception UnsupportedEncodingException if the character set encoding
      // isn't supported
      // @exception IllegalStateException if getInputStream has already been
      // called
      // @exception IOException on other I/O-related errors
      public BufferedReader getReader()
      {
         synchronized (in)
         {
            if (((ServeInputStream) in).isReturnedAsStream())
               throw new IllegalStateException("Already returned as a stream.");
            ((ServeInputStream) in).setReturnedAsReader(true);
         }
         if (charEncoding != null)
            try
            {
               return new BufferedReader(new InputStreamReader(in, charEncoding));
            }
            catch (UnsupportedEncodingException uee)
            {
            }
         return new BufferedReader(new InputStreamReader(in));
      }

      private synchronized Map getParametersFromRequest()
      {
         Map result = null;
         if ("GET".equals(reqMethod))
         {
            if (reqQuery != null)
               try
               {
                  result = Acme.Utils.parseQueryString(reqQuery, charEncoding);
               }
               catch (IllegalArgumentException ex)
               {
                  serve.log("Exception " + ex + " at parsing 'get' data " + reqQuery);
               }
         }
         else if ("POST".equals(reqMethod))
         {
            String contentType = getContentType();
            if (contentType != null && WWWFORMURLENCODE.regionMatches(true, 0, contentType, 0, WWWFORMURLENCODE.length()))
            {
               if (postCache == null)
               {
                  postCache = new String[1];
                  InputStream is = null;
                  try
                  {
                     result = Acme.Utils.parsePostData(getContentLength(), is = getInputStream(), charEncoding,
                             postCache);
                  }
                  catch (Exception ex)
                  {
                     serve.log("Exception " + ex + " at parsing 'POST' data of length " + getContentLength());
                     // TODO propagate the exception ?
                     return EMPTYHASHTABLE;
                  }
               }
               else
                  result = Acme.Utils.parseQueryString(postCache[0], charEncoding);
               if (reqQuery != null && reqQuery.length() > 0)
                  result.putAll(Acme.Utils.parseQueryString(reqQuery, charEncoding));
            }
            else if (reqQuery != null)
               result = Acme.Utils.parseQueryString(reqQuery, charEncoding);
         }
         return result != null ? result : EMPTYHASHTABLE;
      }

      // / Returns the parameter names for this request.
      public synchronized Enumeration getParameterNames()
      {
         if (formParameters == null)
            formParameters = getParametersFromRequest();
         return ((Hashtable) formParameters).keys();
      }

      // / Returns the value of the specified query string parameter, or null
      // if not found.
      // @param name the parameter name
      public String getParameter(String name)
      {
         String[] params = getParameterValues(name);
         if (params == null || params.length == 0)
            return null;

         return params[0];
      }

      // / Returns the values of the specified parameter for the request as an
      // array of strings, or null if the named parameter does not exist.
      public synchronized String[] getParameterValues(String name)
      {
         if (formParameters == null)
            getParameterNames();

         return (String[]) formParameters.get(name);
      }

      // / Returns the value of the named attribute of the request, or null if
      // the attribute does not exist. This method allows access to request
      // information not already provided by the other methods in this
      // interface.
      public Object getAttribute(String name)
      {
         // System.err.println("!!!Get att orig:"+name+"="+attributes.get(name));
         return attributes.get(name);
      }

      // Methods from HttpServletRequest.

      // / Gets the array of cookies found in this request.

      public Cookie[] getCookies()
      {
         Cookie[] cookieArray = new Cookie[inCookies.size()];
         inCookies.copyInto(cookieArray);
         return cookieArray;
      }

      // / Returns the method with which the request was made. This can be
      // "GET",
      // "HEAD", "POST", or an extension method.
      // Same as the CGI variable REQUEST_METHOD.
      public String getMethod()
      {
         return reqMethod;
      }

      /**
       * ****************************************************************************************************************************************************
       * Returns the part of this request's URL from the protocol name up to the query string in the first line of the HTTP request. To reconstruct an URL
       * with a scheme and host, use HttpUtils.getRequestURL(javax.servlet.http.HttpServletRequest).
       */
      // / Returns the full request URI.
      public String getRequestURI()
      {
         return reqUriPathUn;
      }

      /**
       * Reconstructs the URL the client used to make the request. The returned URL contains a protocol, server name, port number, and server path, but it
       * does not include query string parameters. <br>
       * Because this method returns a StringBuffer, not a string, you can modify the URL easily, for example, to append query parameters.
       * <p/>
       * This method is useful for creating redirect messages and for reporting errors.
       *
       * @return a StringBuffer object containing the reconstructed URL
       * @since 2.3
       */
      public java.lang.StringBuffer getRequestURL()
      {
         int port = getServerPort();
         return new StringBuffer().append(getScheme()).append("://").append(getServerName()).append(
                 "https".equals(getScheme()) && port == 443 || port == 80 ? "" : ":" + String.valueOf(port)).append(
                 getRequestURI());
      }

      // / Returns the part of the request URI that referred to the servlet
      // being
      // invoked.
      // Analogous to the CGI variable SCRIPT_NAME.
      public String getServletPath()
      {
         // In this server, the entire path is regexp-matched against the
         // servlet pattern, so there's no good way to distinguish which
         // part refers to the servlet.
         return uriLen > 0 ? reqUriPath.substring(0, uriLen) : "";
      }

      // / Returns optional extra path information following the servlet path,
      // but
      // immediately preceding the query string. Returns null if not
      // specified.
      // Same as the CGI variable PATH_INFO.
      public String getPathInfo()
      {
         // In this server, the entire path is regexp-matched against the
         // servlet pattern, so there's no good way to distinguish which
         // part refers to the servlet.
         return uriLen >= reqUriPath.length() ? null : reqUriPath.substring(uriLen);
      }

      // / Returns extra path information translated to a real path. Returns
      // null if no extra path information was specified.
      // Same as the CGI variable PATH_TRANSLATED.
      public String getPathTranslated()
      {
         // In this server, the entire path is regexp-matched against the
         // servlet pattern, so there's no good way to distinguish which
         // part refers to the servlet.
         return getRealPath(getPathInfo());
      }

      // / Returns the query string part of the servlet URI, or null if not
      // known.
      // Same as the CGI variable QUERY_STRING.
      public String getQueryString()
      {
         return reqQuery;
      }

      // / Returns the name of the user making this request, or null if not
      // known.
      // Same as the CGI variable REMOTE_USER.
      public String getRemoteUser()
      {
         return remoteUser;
      }

      // / Returns the authentication scheme of the request, or null if none.
      // Same as the CGI variable AUTH_TYPE.
      public String getAuthType()
      {
         return authType;
      }

      // / Returns the value of a header field, or null if not known.
      // Same as the information passed in the CGI variabled HTTP_*.
      // @param name the header field name
      public String getHeader(String name)
      {
         int i = reqHeaderNames.indexOf(name.toLowerCase());
         if (i == -1)
            return null;
         return (String) reqHeaderValues.elementAt(i);
      }

      public int getIntHeader(String name)
      {
         String val = getHeader(name);
         if (val == null)
            return -1;
         return Integer.parseInt(val);
      }

      public long getDateHeader(String name)
      {
         String val = getHeader(name);
         if (val == null)
            return -1;
         try
         {
            return headerdateformat.parse(val).getTime();
         }
         catch (ParseException pe)
         {
            try
            {
               return rfc850DateFmt.parse(val).getTime();
            }
            catch (ParseException pe1)
            {
               try
               {
                  return asciiDateFmt.parse(val).getTime();
               }
               catch (ParseException pe3)
               {
                  throw new IllegalArgumentException("Value " + val
                          + " can't be converted to Date using any of formats: [" + headerdateformat.toPattern()
                          + "][ " + rfc850DateFmt.toPattern() + "][" + asciiDateFmt.toPattern());
               }
            }
         }
      }

      // / Returns an Enumeration of the header names.
      public Enumeration getHeaderNames()
      {
         return new Vector(new HashSet(reqHeaderNames)).elements();
      }

      // / Gets the current valid session associated with this request, if
      // create is false or, if necessary, creates a new session for the
      // request, if create is true.
      // <P>
      // Note: to ensure the session is properly maintained, the servlet
      // developer must call this method (at least once) before any output
      // is written to the response.
      // <P>
      // Additionally, application-writers need to be aware that newly
      // created sessions (that is, sessions for which HttpSession.isNew
      // returns true) do not have any application-specific state.
      public synchronized HttpSession getSession(boolean create)
      {
         HttpSession result = null;
         if (sessionValue != null)
         {
            result = serve.getSession(sessionValue);
            if (result != null && ((AcmeSession) result).isValid() == false)
            {
               serve.removeSession(sessionValue);
               result = null;
            }
            //System.err.println("^^^^^^^req sess: "+sessionValue+", found:"+result);
         }
         if (result == null && create)
         {
            result = serve.createSession();
            if (result != null)
            {
               sessionValue = result.getId();
            }
            else
               throw new RuntimeException("A session can't be created");
            //System.err.println("^~~~~~created: "+sessionValue);
         }
         return result;
      }

      // JSDK 2.1
      public HttpSession getSession()
      {
         return getSession(true);
      }

      public boolean isRequestedSessionIdFromURL()
      {
         return isRequestedSessionIdFromUrl();
      }

      // from ServletRequest
      public Enumeration getAttributeNames()
      {
         return attributes.keys();
      }

      /**
       * Stores an attribute in this request. Attributes are reset between requests.
       * This method is most often used in conjunction with RequestDispatcher.
       * <p>Attribute names should follow the same conventions as package names.
       * Names beginning with java.*, javax.*, and com.sun.*, are reserved for
       * use by Sun Microsystems. If the object passed in is null, the effect is
       * the same as calling removeAttribute(java.lang.String).
       * <p/>
       * It is warned that when the request is dispatched from the servlet resides
       * in a different web application by RequestDispatcher, the object set by
       * this method may not be correctly retrieved in the caller servlet.
       *
       * @param name - a String specifying the name of the attribute
       * @param o    - the Object to be stored
       */
      public void setAttribute(String key, Object o)
      {
         //System.err.println("!!!Set att orig:"+key+"="+o);
         //if ("javax.servlet.jsp.jspException".equals(key) && o instanceof Throwable)
         //((Throwable)o).printStackTrace();

         if (o != null)
            attributes.put(key, o);
         else
            attributes.remove(key);
      }

      // / Gets the session id specified with this request. This may differ
      // from the actual session id. For example, if the request specified
      // an id for an invalid session, then this will get a new session with
      // a new id.
      public String getRequestedSessionId()
      {
         return sessionValue;
      }

      // / Checks whether this request is associated with a session that is
      // valid in the current session context. If it is not valid, the
      // requested session will never be returned from the getSession
      // method.
      public boolean isRequestedSessionIdValid()
      {
         if (sessionValue != null)
         {
            AcmeSession session = serve.getSession(sessionValue);
            return (session != null && session.isValid());
         }
         return false;
      }

      /**
       * Checks whether the session id specified by this request came in as a cookie. (The requested session may not be one returned by the getSession
       * method.)
       */
      public boolean isRequestedSessionIdFromCookie()
      {
         return sessionCookieValue != null;
      }

      // / Checks whether the session id specified by this request came in as
      // part of the URL. (The requested session may not be the one returned
      // by the getSession method.)
      public boolean isRequestedSessionIdFromUrl()
      {
         return sessionUrlValue != null;
      }

      // Methods from ServletResponse.

      // / Sets the content length for this response.
      // @param length the content length

      public void setContentLength(int length)
      {
         if (length >= 0)
            setIntHeader(CONTENTLENGTH, length);
         else
            setHeader(CONTENTLENGTH, null);
      }

      // / Sets the content type for this response.
      // @param type the content type
      public void setContentType(String type)
      {
         setHeader(CONTENTTYPE, type != null ? type : "Unknown");
      }

      // / Returns an output stream for writing response data.
      public ServletOutputStream getOutputStream()
      {
         synchronized (out)
         {
            if (rout == null)
            {
               if (pw != null)
                  throw new IllegalStateException("Already returned as a writer");
               rout = out;
            }
         }
         return rout;
      }

      // / Returns a print writer for writing response data. The MIME type of
      // the response will be modified, if necessary, to reflect the character
      // encoding used, through the charset=... property. This means that the
      // content type must be set before calling this method.
      // @exception UnsupportedEncodingException if no such encoding can be
      // provided
      // @exception IllegalStateException if getOutputStream has been called
      // @exception IOException on other I/O errors
      public PrintWriter getWriter() throws IOException
      {
         synchronized (out)
         {
            if (pw == null)
            {
               if (rout != null)
                  throw new IllegalStateException("Already was returned as servlet output stream");
               String encoding = getCharacterEncoding();
               if (encoding != null)
                  pw = new PrintWriter(new OutputStreamWriter(out, encoding));
               else
                  pw = new PrintWriter(out);
            }
         }
         return pw;
      }

      // / Returns the character set encoding used for this MIME body. The
      // character encoding is either the one specified in the assigned
      // content type, or one which the client understands. If no content
      // type has yet been assigned, it is implicitly set to text/plain.
      public String getCharacterEncoding()
      {
         String ct = (String) resHeaderNames.get(CONTENTTYPE.toLowerCase());
         if (ct != null)
         {
            String enc = extractEncodingFromContentType(ct);
            if (enc != null)
               return enc;
         }
         return charEncoding;
      }

      private String extractEncodingFromContentType(String ct)
      {
         if (ct == null)
            return null;
         int scp = ct.indexOf(';');
         if (scp > 0)
         {
            scp = ct.toLowerCase().indexOf("charset=", scp);
            if (scp >= 0)
            {
               ct = ct.substring(scp + "charset=".length()).trim();
               scp = ct.indexOf(';');
               if (scp > 0)
                  ct = ct.substring(0, scp);
               int l = ct.length();
               if (l > 2 && ct.charAt(0) == '"')
                  return ct.substring(1, l - 1);
               return ct;
            }
         }
         return null;
      }

      // 2.2
      // do not use buffer
      public void flushBuffer() throws java.io.IOException
      {
         ((ServeOutputStream) out).flush();
      }

      /**
       * Clears the content of the underlying buffer in the response without clearing headers or status code. If the response has been committed, this method
       * throws an IllegalStateException.
       *
       * @since 2.3
       */
      public void resetBuffer()
      {
         ((ServeOutputStream) out).reset();
         synchronized (this)
         {
            headersWritten = false;
         }
      }

      public int getBufferSize()
      {
         return ((ServeOutputStream) out).getBufferSize();
      }

      public void setBufferSize(int size)
      {
         ((ServeOutputStream) out).setBufferSize(size);
      }

      /**
       * Returns a boolean indicating if the response has been committed. A commited response has already had its status code and headers written.
       *
       * @return a boolean indicating if the response has been committed
       * @see setBufferSize(int), getBufferSize(), flushBuffer(), reset()
       */
      // a caller should think about syncronization
      public boolean isCommitted()
      {
         return headersWritten && ((ServeOutputStream) out).lengthWritten() > 0;
      }

      /**
       * Clears any data that exists in the buffer as well as the status code and headers. If the response has been committed, this method throws an
       * IllegalStateException.
       *
       * @throws java.lang.IllegalStateException
       *          -
       *          if the response has already been committed
       * @see setBufferSize(int), getBufferSize(), flushBuffer(), isCommitted()
       */
      public void reset() throws IllegalStateException
      {
         // new Exception("RESET").printStackTrace();
         if (!isCommitted())
         {
            if (outCookies != null)
               outCookies.clear();
            resHeaderNames.clear();
            pw = null;
            rout = null;
            ((ServeOutputStream) out).reset();
            assureHeaders();
         }
         else
            throw new IllegalStateException("Header have already been committed.");
      }

      /**
       * Sets the locale of the response, setting the headers (including the Content-Type's charset) as appropriate. This method should be called before a
       * call to getWriter(). By default, the response locale is the default locale for the server.
       *
       * @param loc -
       *            the locale of the response
       * @see getLocale()
       */
      public void setLocale(java.util.Locale locale)
      {
         this.locale = locale;
      }

      /**
       * For request: Returns the preferred Locale that the client will accept content in, based on the Accept-Language header. If the client request doesn't
       * provide an Accept-Language header, this method returns the default locale for the server.
       * <p/>
       * For response: Returns the locale specified for this response using the setLocale(java.util.Locale) method. Calls made to setLocale after the response
       * is committed have no effect. If no locale has been specified, the container's default locale is returned.
       */
      public java.util.Locale getLocale()
      {
         if (locale != null)
            return locale;
         Enumeration e = getLocales();
         if (e.hasMoreElements())
            return (Locale) e.nextElement();
         return Locale.getDefault();
      }

      /**
       * Returns an Enumeration of Locale objects indicating, in decreasing order starting with the preferred locale, the locales that are acceptable to the
       * client based on the Accept-Language header. If the client request doesn't provide an Accept-Language header, this method returns an Enumeration
       * containing one Locale, the default locale for the server.
       */
      public Enumeration getLocales()
      {
         // TODO: cache result
         String al = getHeader(ACCEPT_LANGUAGE);
         TreeSet ts = new TreeSet();
         if (al != null)
         {
            // System.err.println("Accept lang:"+al);
            StringTokenizer st = new StringTokenizer(al, ";", false);
            try
            {
               while (st.hasMoreTokens())
               {
                  String langs = st.nextToken(";");
                  // System.err.println("Langs:"+langs);
                  String q = st.nextToken(";=");
                  // System.err.println("q:"+q);
                  q = st.nextToken("=,");
                  // System.err.println("q:"+q);
                  float w = 0;
                  try
                  {
                     w = Float.valueOf(q).floatValue();
                  }
                  catch (NumberFormatException nfe)
                  {
                  }
                  if (w > 0)
                  {
                     StringTokenizer lst = new StringTokenizer(langs, ", ", false);
                     while (lst.hasMoreTokens())
                     {
                        String lan = lst.nextToken();
                        int di = lan.indexOf('-');
                        if (di < 0)
                           ts.add(new LocaleWithWeight(new Locale(lan.trim()) /* 1.4 */, w));
                        else
                           ts.add(new LocaleWithWeight(new Locale(lan.substring(0, di), lan.substring(di + 1)
                                   .trim().toUpperCase()), w));
                     }
                  }
               }
            }
            catch (NoSuchElementException ncee)
            {
               // can't parse
            }
         }
         if (ts.size() == 0)
            ts.add(new LocaleWithWeight(Locale.getDefault(), 1));
         return new AcceptLocaleEnumeration(ts);
      }

      /**
       * Overrides the name of the character encoding used in the body of this request. This method must be called prior to reading request parameters or
       * reading input using getReader().
       *
       * @param a -
       *          String containing the name of the chararacter encoding.
       * @throws java.io.UnsupportedEncodingException
       *          -
       *          if this is not a valid encoding
       * @since JSDK 2.3
       */
      public void setCharacterEncoding(String _enc)
      {
         // TODO: check if encoding is valid
         charEncoding = _enc;
         synchronized (this)
         {
            formParameters = null;
         }
      }

      public void addDateHeader(String header, long date)
      {
         addHeader(header, headerdateformat.format(new Date(date)));
      }

      public void addHeader(String header, String value)
      {
         header = header.trim().toLowerCase();
         Object o = resHeaderNames.get(header);
         if (o == null)
            setHeader(header, value);
         else
         {
            if (o instanceof String[])
            {
               String[] oldVal = (String[]) o;
               String[] newVal = new String[oldVal.length + 1];
               System.arraycopy(oldVal, 0, newVal, 0, oldVal.length);
               newVal[oldVal.length] = value;
               resHeaderNames.put(header, newVal);
            }
            else if (o instanceof String)
            {
               String[] newVal = new String[2];
               newVal[0] = (String) o;
               newVal[1] = value;
               resHeaderNames.put(header, newVal);
            }
            else
               throw new RuntimeException("Invalid content of header hash - " + o.getClass().getName());
         }
      }

      public void addIntHeader(String header, int value)
      {
         addHeader(header, Integer.toString(value));
      }

      public RequestDispatcher getRequestDispatcher(String urlpath)
      {
         if (urlpath.length() > 0 && urlpath.charAt(0) != '/')
         {
            String dispatchPath = getContextPath();
            String pathInfo = getPathInfo();
            String servletPath = getServletPath();
            ;
            if (pathInfo != null)
            {
               dispatchPath += servletPath;
               int slp = pathInfo.indexOf('/', 1);
               if (slp > 0) // can it ever happen?
                  dispatchPath += pathInfo.substring(0, slp - 1);
            }
            else
            {
               int spsp = servletPath.lastIndexOf('/');
               if (spsp >= 0)
                  dispatchPath += servletPath.substring(0, spsp);
            }
            // serve.log("Dispatch path:"+dispatchPath);
            urlpath = dispatchPath + '/' + urlpath;
         }
         return serve.getRequestDispatcher(urlpath);
      }

      public boolean isSecure()
      {
         return "https".equals(getScheme());
      }

      public void removeAttribute(String name)
      {
         attributes.remove(name);
      }

      // only root context supported
      public String getContextPath()
      {
         return "";
      }

      public Enumeration getHeaders(String header)
      {
         Vector result = new Vector();
         int i = -1;
         while ((i = reqHeaderNames.indexOf(header.toLowerCase(), i + 1)) >= 0)
            result.addElement(reqHeaderValues.elementAt(i));
         return result.elements();
      }

      public java.security.Principal getUserPrincipal()
      {
         return null;
      }

      public boolean isUserInRole(String user)
      {
         return false;
      }

      /**
       * Returns a java.util.Map of the parameters of this request. Request parameters are extra information sent with the request. For HTTP servlets,
       * parameters are contained in the query string or posted form data.
       *
       * @return an immutable java.util.Map containing parameter names as keys and parameter values as map values. The keys in the parameter map are of type
       *         String. The values in the parameter map are of type String array.
       * @since 2.3
       */
      public synchronized java.util.Map getParameterMap()
      {
         if (formParameters == null)
            getParameterNames();
         return formParameters;
      }

      // Methods from HttpServletResponse.

      // / Adds the specified cookie to the response. It can be called
      // multiple times to set more than one cookie.

      public void addCookie(Cookie cookie)
      {
         if (outCookies == null)
            outCookies = new Vector();

         outCookies.addElement(cookie);
      }

      // / Checks whether the response message header has a field with the
      // specified name.
      public boolean containsHeader(String name)
      {
         return resHeaderNames.contains(name);
      }

      // JSDK 2.1 extension
      public String encodeURL(String url)
      {
         int uop = url.indexOf(SESSION_URL_NAME);
         // TODO not robust enough
         if (uop > 0)
            url = url.substring(0, uop);
         if (sessionValue == null || isRequestedSessionIdFromCookie())
            return url;
         try
         {
            new URL(url); // for testing syntac
            int ehp = url.indexOf('/');
            if (ehp < 0)
               ehp = url.indexOf('?');
            if (ehp < 0)
               ehp = url.indexOf('#');
            if (ehp < 0)
               ehp = url.length();
            if (url.regionMatches(true, 0, getRequestURL().toString(), 0, ehp) == false)
               return url;
         }
         catch (MalformedURLException e)
         {
         }

         return url + SESSION_URL_NAME + sessionValue;
      }

      public String encodeRedirectURL(String url)
      {
         return encodeURL(url);
      }

      /**
       * Returns the Internet Protocol (IP) source port of the client or last proxy that sent the request.
       *
       * @return an integer specifying the port number
       * @since 2.4
       */
      public int getRemotePort()
      {
         return socket.getPort(); // TODO not quite robust
      }

      /**
       * Returns the host name of the Internet Protocol (IP) interface on which the request was received.
       *
       * @return a <code>String</code> containing the host name of the IP on which the request was received.
       * @since 2.4
       */
      public String getLocalName()
      {
         InetAddress ia = socket/* serve.serverSocket */.getLocalAddress();
         return ia == null ? null : ia.getHostAddress();
      }

      /**
       * Returns the Internet Protocol (IP) address of the interface on which the request was received.
       *
       * @return a <code>String</code> containing the IP address on which the request was received.
       * @since 2.4
       */
      public String getLocalAddr()
      {
         InetAddress ia = /* serve.serverSocket */socket.getLocalAddress();
         return ia == null ? null : ia.getCanonicalHostName(); /* 1.4 */
      }

      /**
       * Returns the Internet Protocol (IP) port number of the interface on which the request was received.
       *
       * @return an integer specifying the port number
       * @since 2.4
       */
      public int getLocalPort()
      {
         return getServerPort();
      }

      // / Sets the status code and message for this response.
      // @param resCode the status code
      // @param resMessage the status message
      public void setStatus(int resCode, String resMessage)
      {
         // if (((ServeOutputStream) out).isInInclude())
         // return;
         this.resCode = resCode;
         this.resMessage = resMessage;
      }

      // / Sets the status code and a default message for this response.
      // @param resCode the status code
      public void setStatus(int resCode)
      {
         switch (resCode)
         {
            case SC_CONTINUE:
               setStatus(resCode, "Continue");
               break;
            case SC_SWITCHING_PROTOCOLS:
               setStatus(resCode, "Switching protocols");
               break;
            case SC_OK:
               setStatus(resCode, "Ok");
               break;
            case SC_CREATED:
               setStatus(resCode, "Created");
               break;
            case SC_ACCEPTED:
               setStatus(resCode, "Accepted");
               break;
            case SC_NON_AUTHORITATIVE_INFORMATION:
               setStatus(resCode, "Non-authoritative");
               break;
            case SC_NO_CONTENT:
               setStatus(resCode, "No content");
               break;
            case SC_RESET_CONTENT:
               setStatus(resCode, "Reset content");
               break;
            case SC_PARTIAL_CONTENT:
               setStatus(resCode, "Partial content");
               break;
            case SC_MULTIPLE_CHOICES:
               setStatus(resCode, "Multiple choices");
               break;
            case SC_MOVED_PERMANENTLY:
               setStatus(resCode, "Moved permanentently");
               break;
            case SC_MOVED_TEMPORARILY:
               setStatus(resCode, "Moved temporarily");
               break;
            case SC_SEE_OTHER:
               setStatus(resCode, "See other");
               break;
            case SC_NOT_MODIFIED:
               setStatus(resCode, "Not modified");
               break;
            case SC_USE_PROXY:
               setStatus(resCode, "Use proxy");
               break;
            case SC_BAD_REQUEST:
               setStatus(resCode, "Bad request");
               break;
            case SC_UNAUTHORIZED:
               setStatus(resCode, "Unauthorized");
               break;
            case SC_PAYMENT_REQUIRED:
               setStatus(resCode, "Payment required");
               break;
            case SC_FORBIDDEN:
               setStatus(resCode, "Forbidden");
               break;
            case SC_NOT_FOUND:
               setStatus(resCode, "Not found");
               break;
            case SC_METHOD_NOT_ALLOWED:
               setStatus(resCode, "Method not allowed");
               break;
            case SC_NOT_ACCEPTABLE:
               setStatus(resCode, "Not acceptable");
               break;
            case SC_PROXY_AUTHENTICATION_REQUIRED:
               setStatus(resCode, "Proxy auth required");
               break;
            case SC_REQUEST_TIMEOUT:
               setStatus(resCode, "Request timeout");
               break;
            case SC_CONFLICT:
               setStatus(resCode, "Conflict");
               break;
            case SC_GONE:
               setStatus(resCode, "Gone");
               break;
            case SC_LENGTH_REQUIRED:
               setStatus(resCode, "Length required");
               break;
            case SC_PRECONDITION_FAILED:
               setStatus(resCode, "Precondition failed");
               break;
            case SC_REQUEST_ENTITY_TOO_LARGE:
               setStatus(resCode, "Request entity too large");
               break;
            case SC_REQUEST_URI_TOO_LONG:
               setStatus(resCode, "Request URI too long");
               break;
            case SC_UNSUPPORTED_MEDIA_TYPE:
               setStatus(resCode, "Unsupported media type");
               break;
            case SC_INTERNAL_SERVER_ERROR:
               setStatus(resCode, "Internal server error");
               break;
            case SC_NOT_IMPLEMENTED:
               setStatus(resCode, "Not implemented");
               break;
            case SC_BAD_GATEWAY:
               setStatus(resCode, "Bad gateway");
               break;
            case SC_SERVICE_UNAVAILABLE:
               setStatus(resCode, "Service unavailable");
               break;
            case SC_GATEWAY_TIMEOUT:
               setStatus(resCode, "Gateway timeout");
               break;
            case SC_HTTP_VERSION_NOT_SUPPORTED:
               setStatus(resCode, "HTTP version not supported");
               break;
            case 207:
               setStatus(resCode, "Multi Status");
               break;
            default:
               setStatus(resCode, "");
               break;
         }
      }

      // / Sets the value of a header field.
      // @param name the header field name
      // @param value the header field value
      public void setHeader(String header, String value)
      {
         header = header.trim().toLowerCase(); // normilize header
         if (value == null)
            resHeaderNames.remove(header);
         else
         {
            resHeaderNames.put(header, value);
            //if (header.equals(CONTENTTYPE)) {
            //	String enc = extractEncodingFromContentType(value);
            //	if (enc != null)
            //		setCharacterEncoding(enc);
            //}
         }
      }

      // / Sets the value of an integer header field.
      // @param name the header field name
      // @param value the header field integer value
      public void setIntHeader(String header, int value)
      {
         setHeader(header, Integer.toString(value));
      }

      // / Sets the value of a long header field.
      // @param name the header field name
      // @param value the header field long value
      public void setLongHeader(String header, long value)
      {
         setHeader(header, Long.toString(value));
      }

      // / Sets the value of a date header field.
      // @param name the header field name
      // @param value the header field date value
      public void setDateHeader(String header, long value)
      {
         setHeader(header, headerdateformat.format(new Date(value)));
      }

      // / Writes the status line and message headers for this response to the
      // output stream.
      // @exception IOException if an I/O error has occurred
      void writeHeaders() throws IOException
      {
         synchronized (this)
         {
            // TODO: possible to write trailer when chunked out,
            // so chunked out should be global flag
            if (headersWritten)
               return;

            headersWritten = true;
         }
         if (reqMime)
         {
            boolean chunked_out = false;
            boolean wasContentLen = false;
            if (resMessage.length() < 256)
               out.println(reqProtocol + " " + resCode + " " + resMessage.replace('\r', '/').replace('\n', '/'));
            else
               out.println(reqProtocol + " " + resCode + " "
                       + resMessage.substring(0, 255).replace('\r', '/').replace('\n', '/'));
            Enumeration he = resHeaderNames.keys();
            while (he.hasMoreElements())
            {
               String name = (String) he.nextElement();
               Object o = resHeaderNames.get(name);
               if (o instanceof String)
               {
                  String value = (String) o;
                  if (value != null)
                  {// just in case
                     out.println(name + ": " + value);
                     if (wasContentLen == false)
                        if (CONTENTLENGTH.equals(name))
                           try
                           {
                              wasContentLen = Long.parseLong(value) > 0;
                           }
                           catch (NumberFormatException nfe)
                           {
                           }
                     if (chunked_out == false)
                        if (TRANSFERENCODING.equals(name) && CHUNKED.equals(value))
                           chunked_out = true;
                  }
               }
               else if (o instanceof String[])
               {
                  String[] values = (String[]) o;
                  out.print(name + ": " + values[0]);
                  for (int i = 1; i < values.length; i++)
                     out.print("," + values[i]);
                  out.println();
               }
            }
            StringBuffer sb = null;
            StringBuffer sb2 = null;
            Cookie cc = null;
            // add session cookie
            if (sessionValue != null)
            {
               HttpSession session = serve.getSession(sessionValue);
               if (session != null)
               {
                  if (((AcmeSession) session).isValid())
                  {
                     if (session.isNew())
                     {
                        cc = new Cookie(SESSION_COOKIE_NAME, sessionValue);
                        if (serve.expiredIn < 0)
                           cc.setMaxAge(Math.abs(serve.expiredIn) * 60);
                        ServletContext sc = ((AcmeSession) session).getServletContext();
                        try
                        {
                           String cp = (String) sc.getClass().getMethod("getContextPath", Utils.EMPTY_CLASSES)
                                   .invoke(sc, Utils.EMPTY_OBJECTS);
                           if (cp.length() == 0)
                              cp = "/";
                           cc.setPath(cp);
                        }
                        catch (Exception e)
                        {

                        }

                        addCookie(cc);
                     }
                  }
                  else
                  {
                     cc = new Cookie(SESSION_COOKIE_NAME, "");
                     cc.setMaxAge(0);
                     addCookie(cc);
                  }
               }
            }

            // how to remove a cookie
            // cc = new Cookie(cookieName, "");
            // cc.setMaxAge(0);
            //
            for (int i = 0; outCookies != null && i < outCookies.size(); i++)
            {
               cc = (Cookie) outCookies.elementAt(i);
               if (cc.getSecure() && isSecure() == false)
                  continue;
               int version = cc.getVersion();
               String token;
               if (version > 1)
               {
                  if (sb2 == null)
                     sb2 = new StringBuffer(SETCOOKIE + "2: ");
                  else
                     sb2.append(',');
                  sb2.append(cc.getName());
                  sb2.append("=\"");
                  sb2.append(cc.getValue()).append('"');
                  token = cc.getComment();
                  if (token != null)
                     sb2.append("; Comment=\"").append(token).append('"');
                  token = cc.getDomain();
                  if (token != null)
                     sb2.append("; Domain=\"").append(token).append('"');
                  if (cc.getMaxAge() >= 0)
                     sb2.append("; Max-Age=\"").append(cc.getMaxAge()).append('"');
                  token = cc.getPath();
                  if (token != null)
                     sb2.append("; Path=\"").append(token).append('"');
                  if (cc.getSecure())
                  {
                     sb2.append("; Secure");
                  }
                  sb2.append("; Version=\"").append(version).append('"');
               }
               else
               {
                  if (sb == null)
                     sb = new StringBuffer(SETCOOKIE + ": ");
                  else
                     //sb.append(',');
                     sb.append("\r\n" + SETCOOKIE + ": "); // for IE not
                  sb.append(cc.getName());
                  sb.append('=');
                  sb.append(cc.getValue());//.append('"');
                  if (cc.getDomain() != null && cc.getDomain().length() > 0)
                  {
                     sb.append("; domain=" + cc.getDomain());
                  }
                  if (cc.getMaxAge() >= 0)
                  {
                     sb.append("; expires=");
                     sb.append(expdatefmt.format(new Date(new Date().getTime() + 1000l * cc.getMaxAge())));
                  }
                  if (cc.getPath() != null && cc.getPath().length() > 0)
                  {
                     sb.append("; path=" + cc.getPath());
                  }
                  if (cc.getSecure())
                  {
                     sb.append("; secure");
                  }
               }
            }
            if (sb != null)
            {
               out.println(sb.toString());
               //System.err.println("We sent cookies: " + sb);
            }
            if (sb2 != null)
            {
               out.println(sb2.toString());
               //System.err.println("We sent cookies 2: " + sb2);
            }
            // Test for existence of message body
            if (containsBody() && wasContentLen == false && chunked_out == false && serve.isKeepAlive())
            {
               out.println(TRANSFERENCODING + ": " + CHUNKED);
               chunked_out = true;
            }
            out.println();
            out.flush();
            ((ServeOutputStream) out).setChunked(chunked_out);
         }
      }
      
      private boolean containsBody()
      {
         return !("HEAD".equalsIgnoreCase(reqMethod) || (100 <= resCode && resCode < 200) || resCode == 204 || resCode == 304);
      }

      // / Writes an error response using the specified status code and
      // message.
      // @param resCode the status code
      // @param resMessage the status message
      // @exception IOException if an I/O error has occurred
      public void sendError(int resCode, String resMessage) throws IOException
      {
         setStatus(resCode, resMessage);
         realSendError();
      }

      // / Writes an error response using the specified status code and a
      // default
      // message.
      // @param resCode the status code
      // @exception IOException if an I/O error has occurred
      public void sendError(int resCode) throws IOException
      {
         setStatus(resCode);
         realSendError();
      }

      public void setInInclude(boolean set)
      {
         ((ServeOutputStream) out).setInInclude(set);
      }

      private void realSendError() throws IOException
      {
         if (isCommitted())
            throw new IllegalStateException("Can not send an error, headers have been already written");
         // if (((ServeOutputStream) out).isInInclude()) // ignore
         // return;
         setContentType("text/html");
         StringBuffer sb = new StringBuffer(100);
         int lsp = resMessage.indexOf('\n');
         sb.append("<HTML><HEAD>").append(
                 "<TITLE>" + resCode + " " + (lsp < 0 ? resMessage : resMessage.substring(0, lsp)) + "</TITLE>")
                 .append("</HEAD><BODY " + BGCOLOR).append(
                 "><H2>" + resCode + " " + (lsp < 0 ? resMessage : resMessage.substring(0, lsp)) + "</H2>");
         if (lsp > 0)
            sb.append("<PRE>").append(Utils.htmlEncode(resMessage.substring(lsp), false)).append("</PRE>");
         sb.append("<HR>");
         sb.append(Identification.serverIdHtml);
         sb.append("</BODY></HTML>");
         setContentLength(sb.length());
         out.print(sb.toString());
         closeStreams();
      }

      // / Sends a redirect message to the client using the specified redirect
      // location URL.
      // @param location the redirect location URL
      // @exception IOException if an I/O error has occurred
      public void sendRedirect(String location) throws IOException
      {
         if (isCommitted())
            throw new IllegalStateException("Can not redirect, headers have been already written");
         if (location.indexOf(":/") < 0)
         { // relative
            String portString = "";
            if ("https".equalsIgnoreCase(getScheme()))
            {
               if (getServerPort() != 443)
                  portString = ":" + getServerPort();
            }
            else if (getServerPort() != 80)
               portString = ":" + getServerPort();

            if (location.length() > 0 && location.charAt(0) == '/')
            {
               location = getScheme() + "://" + getServerName() + portString + location;
            }
            else
            {
               int sp = reqUriPathUn.lastIndexOf('/');
               String uri;
               if (sp < 0)
               {
                  uri = reqUriPathUn + '/';
                  sp = uri.length();
               }
               else
               {
                  uri = reqUriPathUn;
                  sp++;
               }
               location = getScheme() + "://" + getServerName() + portString + uri.substring(0, sp) + location;
            }
         }
         // serve.log("location:"+location);
         setHeader("Location", location);
         setStatus(SC_MOVED_TEMPORARILY);
         setContentType("text/html");
         StringBuffer sb = new StringBuffer(200);
         sb.append("<HTML><HEAD>" + "<TITLE>" + SC_MOVED_TEMPORARILY + " Moved</TITLE>" + "</HEAD><BODY " + BGCOLOR
                 + "><H2>" + SC_MOVED_TEMPORARILY + " Moved</H2>" + "This document has moved <a href=" + location
                 + ">here.<HR>");
         sb.append(Identification.serverIdHtml);
         sb.append("</BODY></HTML>");
         setContentLength(sb.length());
         // to avoid further out
         out.print(sb.toString());
         closeStreams();
      }

      // URL session-encoding stuff. Not implemented, but the API is here
      // for compatibility.

      // / Encodes the specified URL by including the session ID in it, or, if
      // encoding is not needed, returns the URL unchanged. The
      // implementation of this method should include the logic to determine
      // whether the session ID needs to be encoded in the URL. For example,
      // if the browser supports cookies, or session tracking is turned off,
      // URL encoding is unnecessary.
      // <P>
      // All URLs emitted by a Servlet should be run through this method.
      // Otherwise, URL rewriting cannot be used with browsers which do not
      // support cookies.
      // @deprecated

      public String encodeUrl(String url)
      {
         return encodeURL(url);
      }

      // / Encodes the specified URL for use in the sendRedirect method or, if
      // encoding is not needed, returns the URL unchanged. The
      // implementation of this method should include the logic to determine
      // whether the session ID needs to be encoded in the URL. Because the
      // rules for making this determination differ from those used to
      // decide whether to encode a normal link, this method is seperate
      // from the encodeUrl method.
      // <P>
      // All URLs sent to the HttpServletResponse.sendRedirect method should
      // be
      // run through this method. Otherwise, URL rewriting cannot be used with
      // browsers which do not support cookies.
      public String encodeRedirectUrl(String url)
      {
         return encodeRedirectURL(url);
      }

      public Socket getSocket()
      {
         // TODO apply security check
         return socket;
      }
   }

   protected static class BasicAuthRealm extends Hashtable
   {
      String name;

      BasicAuthRealm(String name)
      {
         this.name = name;
      }

      String name()
      {
         return name;
      }
   }

   public static class ServeInputStream extends ServletInputStream
   {
      private final static Logger LOG = Logger.getLogger(ServeInputStream.class.getName());

      private final static boolean DEBUG_ON = LOG.isLoggable(Level.FINER);

      /**
       * The actual input stream (buffered).
       */
      private InputStream in, origIn;

      private ServeConnection conn;

      private int chunksize = 0;

      private boolean chunking = false, compressed;

      private boolean returnedAsReader, returnedAsStream;

      private long contentLength = -1;

      private long readCount;

      private byte[] oneReadBuf = new byte[1];

      private boolean closed;

      /* ------------------------------------------------------------ */
      /**
       * Constructor
       */
      public ServeInputStream(InputStream in, ServeConnection conn)
      {
         this.conn = conn;
         this.in = new BufferedInputStream(in);
      }

      void refresh()
      {
         returnedAsReader = false;
         returnedAsStream = false;
         contentLength = -1;
         readCount = 0;
         chunksize = 0;
         closed = false;
         compressed(false);
      }

      /* ------------------------------------------------------------ */
      /**
       * @param chunking
       */
      public void chunking(boolean chunking)
      {
         if (contentLength == -1)
            this.chunking = chunking;
      }

      boolean compressed(boolean on)
      {
         if (on)
         {
            if (compressed == false)
            {
               origIn = in;
               try
               {
                  ServeInputStream sis = new ServeInputStream(in, conn);
                  if (chunking)
                  {
                     sis.chunking(true);
                     chunking(false);
                  }
                  in = (InputStream) conn.serve.gzipInStreamConstr.newInstance(new Object[]{sis});
                  compressed = true;
                  //conn.serve.log("Compressed stream was created with success", null);
               }
               catch (Exception ex)
               {
                  if (ex instanceof InvocationTargetException)
                     conn.serve.log("Problem in compressed stream creation", ((InvocationTargetException) ex).getTargetException());
                  else
                     conn.serve.log("Problem in compressed stream obtaining", ex);
               }
            }
         }
         else if (compressed)
         {
            compressed = false;
            in = origIn;
         }
         return compressed;
      }

      /**
       * sets max read byte in input
       */
      void setContentLength(long contentLength)
      {
         if (this.contentLength == -1 && contentLength >= 0 && chunking == false)
         {
            this.contentLength = contentLength;
            readCount = 0;
         }
      }

      /* ------------------------------------------------------------ */
      /**
       * Read a line ended by CRLF, used internally only for reading headers.
       * No char encoding, ASCII only
       */
      protected String readLine(int maxLen) throws IOException
      {
         if (maxLen <= 0)
            throw new IllegalArgumentException("Max len:" + maxLen);
         StringBuffer buf = new StringBuffer(Math.min(1024, maxLen));

         int c;
         boolean cr = false;
         int i = 0;
         while ((c = in.read()) != -1)
         {
            if (c == 10)
            { // LF
               if (cr)
                  break;
               break;
               //throw new IOException ("LF without CR");
            }
            else if (c == 13) // CR
               cr = true;
            else
            {
               //if (cr)
               //throw new IOException ("CR without LF");
               // see http://www.w3.org/Protocols/HTTP/1.1/rfc2616bis/draft-lafon-rfc2616bis-03.html#tolerant.applications
               cr = false;
               if (i >= maxLen)
                  throw new IOException("Line lenght exceeds " + maxLen);
               buf.append((char) c);
               i++;
            }
         }
         if (DEBUG_ON)
            LOG.finer(String.valueOf(buf));
         if (c == -1 && buf.length() == 0)
            return null;

         return buf.toString();
      }

      /* ------------------------------------------------------------ */
      public int read() throws IOException
      {
         int result = read(oneReadBuf, 0, 1);
         if (result == 1)
            return 255 & oneReadBuf[0];
         return -1;
      }

      /* ------------------------------------------------------------ */
      public int read(byte b[]) throws IOException
      {
         return read(b, 0, b.length);
      }

      /* ------------------------------------------------------------ */
      public synchronized int read(byte b[], int off, int len) throws IOException
      {
         if (closed)
            throw new IOException("The stream is already closed");
         if (chunking)
         {
            if (chunksize <= 0 && getChunkSize() <= 0)
               return -1;
            if (len > chunksize)
               len = chunksize;
            len = in.read(b, off, len);
            chunksize = (len < 0) ? -1 : (chunksize - len);
         }
         else
         {
            if (contentLength >= 0)
            {
               if (contentLength - readCount < Integer.MAX_VALUE)

                  len = Math.min(len, (int) (contentLength - readCount));
               if (len <= 0)
               {
                  LOG.finer("EOF");
                  return -1;
               }
               len = in.read(b, off, len);
               if (len > 0)
                  readCount += len;
            }
            else
               // to avoid extra if
               len = in.read(b, off, len);
         }
         if (DEBUG_ON && len > 0)
            LOG.finer(new String(b, off, len));

         return len;
      }

      /* ------------------------------------------------------------ */
      public long skip(long len) throws IOException
      {
         if (DEBUG_ON)
            LOG.finer("instream.skip() :" + len);
         if (closed)
            throw new IOException("The stream is already closed");
         if (chunking)
         {
            if (chunksize <= 0 && getChunkSize() <= 0)
               return -1;
            if (len > chunksize)
               len = chunksize;
            len = in.skip(len);
            chunksize = (len < 0) ? -1 : (chunksize - (int) len);
         }
         else
         {
            if (contentLength >= 0)
            {
               len = Math.min(len, contentLength - readCount);
               if (len <= 0)
                  return -1;
               len = in.skip(len);
               readCount += len;
            }
            else
               len = in.skip(len);
         }
         return len;
      }

      /* ------------------------------------------------------------ */
      /**
       * Available bytes to read without blocking. If you are unlucky may return 0 when there are more
       */
      public int available() throws IOException
      {
         LOG.finer("instream.available()");
         if (closed)
            throw new IOException("The stream is already closed");
         if (chunking)
         {
            int len = in.available();
            if (len <= chunksize)
               return len;
            return chunksize;
         }

         if (contentLength >= 0)
         {
            int len = in.available();
            if (contentLength - readCount < Integer.MAX_VALUE)
               return Math.min(len, (int) (contentLength - readCount));
            return len;
         }
         else
            return in.available();
      }

      /* ------------------------------------------------------------ */
      public void close() throws IOException
      {
         // keep alive, will be closed by socket
         // in.close();
         LOG.finer("instream.close() " + closed);
         if (closed)
            return; //throw new IOException("The stream is already closed");
         // read until end of chunks or content length
         if (chunking)
            while (read() >= 0) ;
         else if (contentLength < 0) ;
         else
         {
            long skipCount = contentLength - readCount;
            while (skipCount > 0)
            {
               long skipped = skip(skipCount);
               if (skipped <= 0)
                  break;
               skipCount -= skipped;
            }
         }
         if (conn.keepAlive == false)
            in.close();
         closed = true;
      }

      /* ------------------------------------------------------------ */
      /**
       * Mark is not supported
       *
       * @return false
       */
      public boolean markSupported()
      {
         return false;
      }

      /* ------------------------------------------------------------ */
      /**
       *
       */
      public void reset() throws IOException
      {
         // no buffering, so not possible
         if (closed)
            throw new IOException("The stream is already closed");
         LOG.finer("instream.reset()");
         in.reset();
      }

      /* ------------------------------------------------------------ */
      /**
       * Not Implemented
       *
       * @param readlimit
       */
      public void mark(int readlimit)
      {
         // not supported
         if (DEBUG_ON)
            LOG.finer("instream.mark(" + readlimit + ")");
      }

      /* ------------------------------------------------------------ */
      private int getChunkSize() throws IOException
      {
         if (chunksize < 0)
            return -1;

         chunksize = -1;

         // Get next non blank line
         chunking = false;
         String line = readLine(60);
         while (line != null && line.length() == 0)
            line = readLine(60);
         chunking = true;

         // Handle early EOF or error in format
         if (line == null)
            return -1;

         // Get chunksize
         int i = line.indexOf(';');
         if (i > 0)
            line = line.substring(0, i).trim();
         try
         {
            chunksize = Integer.parseInt(line, 16);
         }
         catch (NumberFormatException nfe)
         {
            throw new IOException("Chunked stream is broken, " + line);
         }

         // check for EOF
         if (chunksize == 0)
         {
            chunksize = -1;
            // Look for footers
            readLine(60);
            chunking = false;
         }
         return chunksize;
      }

      boolean isReturnedAsStream()
      {
         return returnedAsStream;
      }

      void setReturnedAsStream(boolean _on)
      {
         returnedAsStream = _on;
      }

      boolean isReturnedAsReader()
      {
         return returnedAsReader;
      }

      void setReturnedAsReader(boolean _on)
      {
         returnedAsReader = _on;
      }
   }

   public static class ServeOutputStream extends ServletOutputStream
   {

      private static final Logger LOG = Logger.getLogger(ServeOutputStream.class.getName());

      private final static boolean DEBUG_ON = LOG.isLoggable(Level.FINER);

      private boolean chunked;

      private boolean closed;

      // TODO: predefine as static byte[] used by chunked
      // underneath stream
      private OutputStream out;

      // private BufferedWriter writer; // for top speed
      private ServeConnection conn;

      private int inInclude;

      private String encoding;

      private/*volatile*/ long lbytes;

      private Utils.SimpleBuffer buffer;

      public ServeOutputStream(OutputStream out, ServeConnection conn)
      {
         this.out = out;
         this.conn = conn;
         buffer = new Utils.SimpleBuffer();
         encoding = conn.getCharacterEncoding();
         if (encoding == null)
            encoding = Utils.ISO_8859_1;
      }

      void refresh()
      {
         chunked = false;
         closed = false;
         inInclude = 0;
         lbytes = 0;
         buffer.reset();
         encoding = conn.getCharacterEncoding();
         if (encoding == null)
            encoding = Utils.ISO_8859_1;
      }

      protected void reset()
      {
         if (lbytes == 0)
            buffer.reset();
         else
            throw new IllegalStateException("Result was already committed");
      }

      protected int getBufferSize()
      {
         return buffer.getSize();
      }

      protected void setBufferSize(int size)
      {
         if (lbytes > 0)
            throw new IllegalStateException("Bytes already written in response");
         buffer.setSize(size);
      }

      protected void setChunked(boolean set)
      {
         chunked = set;
      }

      public void print(String s) throws IOException
      {
         write(s.getBytes(encoding));
      }

      public void write(int b) throws IOException
      {
         write(new byte[]{(byte) b}, 0, 1);
      }

      public void write(byte[] b) throws IOException
      {
         write(b, 0, b.length);
      }

      public void write(byte[] b, int off, int len) throws IOException
      {
         if (closed) {
            if (DEBUG_ON) {
               LOG.finer((b == null ? "null" : new String(b, off, len)) + "\n won't be written, stream closed.");
            }
            throw new IOException("An attempt of writing " + len + " bytes to a closed out.");
         }

         if (len == 0)
            return;
         //
         conn.writeHeaders();
         b = buffer.put(b, off, len);
         len = b.length;
         if (len == 0)
            return;
         off = 0;
         if (chunked)
         {
            String hexl = Integer.toHexString(len);
            out.write((hexl + "\r\n").getBytes()); // no encoding Ok
            lbytes += 2 + hexl.length();
            out.write(b, off, len);
            lbytes += len;
            out.write("\r\n".getBytes());
            lbytes += 2;
         }
         else
         {
            out.write(b, off, len);
            lbytes += len;
         }

         if (DEBUG_ON) {
            if (chunked)
               LOG.finer(Integer.toHexString(len));
            LOG.finer(new String(b, off, len));
            if (chunked)
               LOG.finer("end of chunk");
         }
      }

      public void flush() throws IOException
      {
         if (closed)
            return;
         // throw new IOException("An attempt of flushig closed out.");
         conn.writeHeaders();
         byte[] b = buffer.get();
         if (b.length > 0)
         {
            if (chunked)
            {
               String hexl = Integer.toHexString(b.length);
               out.write((hexl + "\r\n").getBytes()); // no encoding Ok
               lbytes += 2 + hexl.length();
               out.write(b);
               lbytes += b.length;
               out.write("\r\n".getBytes());
               lbytes += 2;
               if (DEBUG_ON) {
                  LOG.finer(hexl);
                  LOG.finer(new String(b));
               }
            }
            else
            {
               out.write(b);
               lbytes += b.length;
               if (DEBUG_ON) {
                  LOG.finer(new String(b));
               }
            }
         }
         out.flush();
      }

      public void close() throws IOException
      {
         if (closed)
            return;
         // throw new IOException("Stream is already closed.");
         // new IOException("Stream closing").printStackTrace();
         try
         {
            flush();
            if (inInclude == 0)
            {
               if (chunked)
               {
                  out.write("0\r\n\r\n".getBytes());
                  lbytes += 5;
                  LOG.finer("0\r\n\r\n");
                  // TODO: here is possible to write trailer headers
                  out.flush();
               }
               if (conn.keepAlive == false)
                  out.close();
            }
         }
         finally
         {
            closed = true;
         }
      }

      private long lengthWritten()
      {
         return lbytes;
      }

      boolean isInInclude()
      {
         return inInclude == 0;
      }

      void setInInclude(boolean _set)
      {
         inInclude = _set ? 1 : 0;
         /*if (_set)
               inInclude++;
            else
               inInclude--;
            if (inInclude < 0)
               throw new IllegalStateException("Not matching include set");*/
      }
   }

   /**
    * Class PathTreeDictionary - this class allows to put path elements in format n1/n2/n2[/*.ext] and get match to a pattern and a unmatched tail
    */
   public static class PathTreeDictionary
   {
      Node root_node;

      public PathTreeDictionary()
      {
         root_node = new Node();
      }

      public synchronized void put(String path, Object value)
      {
         StringTokenizer st = new StringTokenizer(path, "\\/");
         Node cur_node = root_node;
         while (st.hasMoreTokens())
         {
            String nodename = st.nextToken();
            Node node = (Node) cur_node.get(nodename);
            if (node == null)
            {
               node = new Node();
               cur_node.put(nodename, node);
            }
            cur_node = node;
         }
         cur_node.object = value;
      }

      public synchronized Object[] remove(Object value)
      {
         return remove(root_node, value);
      }

      public synchronized Object[] remove(String path)
      {
         Object[] result = get(path);
         if (result[1] != null)
            return remove(result[1]);
         return result;
      }

      public Object[] remove(Node node, Object value)
      {
         // TODO make full path, not only last element
         Enumeration e = node.keys();
         while (e.hasMoreElements())
         {
            String path = (String) e.nextElement();
            Node childNode = (Node) node.get(path);
            if (childNode.object == value)
            {// it's safe because the same instance can't be shared for several paths in this design
               childNode.object = null;
               return new Object[]{value, new Integer(0)};
            }
            Object[] result = remove(childNode, value);
            if (result[0] != null)
               return result;
         }

         return new Object[]{null, null};
      }

      /**
       * This function looks up in the directory to find the perfect match and remove matching part from path, so if you need to keep original path, save it
       * somewhere
       */
      public Object[] get(String path)
      {
         Object[] result = new Object[2];
         if (path == null)
            return result;
         char[] ps = path.toCharArray();
         Node cur_node = root_node;
         int p0 = 0, lm = 0; // last match
         result[0] = cur_node.object;
         boolean div_state = true;
         for (int i = 0; i < ps.length; i++)
         {
            if (ps[i] == '/' || ps[i] == '\\')
            {
               if (div_state)
                  continue;
               Node node = (Node) cur_node.get(new String(ps, p0, i - p0));
               if (node == null)
               {
                  result[1] = new Integer(lm);
                  return result;
               }
               if (node.object != null)
               {
                  result[0] = node.object;
                  lm = i;
               }
               cur_node = node;
               div_state = true;
            }
            else
            {
               if (div_state)
               {
                  p0 = i;
                  div_state = false;
               }
            }
         }
         cur_node = (Node) cur_node.get(new String(ps, p0, ps.length - p0));
         if (cur_node != null && cur_node.object != null)
         {
            result[0] = cur_node.object;
            lm = ps.length;
         }
         result[1] = new Integer(lm);
         return result;
      }

      public Enumeration keys()
      {
         Vector result = new Vector();
         addSiblingNames(root_node, result, "");
         return result.elements();
      }

      public void addSiblingNames(Node node, Vector result, String path)
      {
         Enumeration e = node.keys();
         while (e.hasMoreElements())
         {
            String pc = (String) e.nextElement();
            Node childNode = (Node) node.get(pc);
            pc = path + '/' + pc;
            if (childNode.object != null)
               result.addElement(pc);
            addSiblingNames(childNode, result, pc);
         }
      }

      public Enumeration elements()
      {
         Vector result = new Vector();
         addSiblingObjects(root_node, result);
         return result.elements();
      }

      public void addSiblingObjects(Node node, Vector result)
      {
         Enumeration e = node.keys();
         while (e.hasMoreElements())
         {
            Node childNode = (Node) node.get(e.nextElement());
            if (childNode.object != null)
               result.addElement(childNode.object);
            addSiblingObjects(childNode, result);
         }
      }

      class Node extends Hashtable
      {
         Object object;
      }
   }

   /**
    * Http session support
    * <p/>
    * TODO: provide lazy session restoring, it should allow to load classes from wars 1st step it read serialization data and store under session attribute 2nd
    * when the session requested, it tries to deserialize all session attributes considered that all classes available
    */
   public static class AcmeSession extends Hashtable implements HttpSession
   {
      private long createTime;

      private long lastAccessTime;

      private String id;

      private int inactiveInterval; // in seconds

      private boolean expired;

      private transient ServletContext servletContext;

      private transient HttpSessionContext sessionContext;

      private transient List listeners;

      // TODO: check in documentation what is default inactive interval and
      // what
      // means 0
      // and what is mesurement unit
      AcmeSession(String id, ServletContext servletContext, HttpSessionContext sessionContext)
      {
         this(id, 0, servletContext, sessionContext);
      }

      AcmeSession(String id, int inactiveInterval, ServletContext servletContext, HttpSessionContext sessionContext)
      {
         // new Exception("Session created with: "+servletContext).printStackTrace(); //!!!
         createTime = System.currentTimeMillis();
         this.id = id;
         this.inactiveInterval = inactiveInterval;
         this.servletContext = servletContext;
         this.sessionContext = sessionContext;
      }

      public long getCreationTime()
      {
         return createTime;
      }

      public String getId()
      {
         return id;
      }

      public long getLastAccessedTime()
      {
         return lastAccessTime;
      }

      public void setMaxInactiveInterval(int interval)
      {
         inactiveInterval = interval;
      }

      public int getMaxInactiveInterval()
      {
         return inactiveInterval;
      }

      /**
       * @deprecated As of Version 2.1 of interface javax.servlet.http.HttpSession,
       * this method is deprecated and has no replacement.
       * It will be removed in a future version of the Java Servlet API.
       */
      public HttpSessionContext getSessionContext()
      {
         return sessionContext;
      }

      /**
       * Returns the ServletContext to which this session belongs.
       *
       * @return The ServletContext object for the web application
       * @ince 2.3
       */
      public ServletContext getServletContext()
      {
         // System.err.println("ctx from:"+servletContext); //!!!
         return servletContext;
      }

      public java.lang.Object getAttribute(java.lang.String name) throws IllegalStateException
      {
         if (expired)
            throw new IllegalStateException();
         return get((Object) name);
      }

      public java.lang.Object getValue(java.lang.String name) throws IllegalStateException
      {
         return getAttribute(name);
      }

      public java.util.Enumeration getAttributeNames() throws IllegalStateException
      {
         if (expired)
            throw new IllegalStateException();
         return keys();
      }

      public java.lang.String[] getValueNames() throws IllegalStateException
      {
         Enumeration e = getAttributeNames();
         Vector names = new Vector();
         while (e.hasMoreElements())
            names.addElement(e.nextElement());
         String[] result = new String[names.size()];
         names.copyInto(result);
         return result;
      }

      public void setAttribute(String name, Object value) throws IllegalStateException
      {
         if (expired)
            throw new IllegalStateException();
         Object oldValue = value != null ? put((Object) name, value) : remove(name);
         if (oldValue != null)
            if (oldValue instanceof HttpSessionBindingListener)
               ((HttpSessionBindingListener) oldValue).valueUnbound(new HttpSessionBindingEvent(this, name));
            else if (oldValue instanceof HttpSessionAttributeListener)
               ((HttpSessionAttributeListener) oldValue).attributeReplaced(new HttpSessionBindingEvent(this, name,
                       value));
         if (value instanceof HttpSessionBindingListener)
            ((HttpSessionBindingListener) value).valueBound(new HttpSessionBindingEvent(this, name));
         else if (value instanceof HttpSessionAttributeListener)
            ((HttpSessionAttributeListener) value).attributeAdded(new HttpSessionBindingEvent(this, name));
      }

      public void putValue(String name, Object value) throws IllegalStateException
      {
         setAttribute(name, value);
      }

      public void removeAttribute(java.lang.String name) throws IllegalStateException
      {
         if (expired)
            throw new IllegalStateException();
         Object value = remove((Object) name);
         if (value != null)
            if (value instanceof HttpSessionBindingListener)
               ((HttpSessionBindingListener) value).valueUnbound(new HttpSessionBindingEvent(this, name));
            else if (value instanceof HttpSessionAttributeListener)
               ((HttpSessionAttributeListener) value).attributeRemoved(new HttpSessionBindingEvent(this, name));
      }

      public void removeValue(java.lang.String name) throws IllegalStateException
      {
         removeAttribute(name);
      }

      public synchronized void invalidate() throws IllegalStateException
      {
         if (expired)
            throw new IllegalStateException();
         notifyListeners();
         Enumeration e = getAttributeNames();
         while (e.hasMoreElements())
         {
            removeAttribute((String) e.nextElement());
         }
         setExpired(true);
         // would be nice remove it from hash table also
      }

      public boolean isNew() throws IllegalStateException
      {
         if (expired)
            throw new IllegalStateException();
         return lastAccessTime == 0;
      }

      public synchronized void setListeners(List l)
      {
         if (listeners == null)
         {
            listeners = l;
            if (listeners != null)
            {
               HttpSessionEvent event = new HttpSessionEvent(this);
               for (int i = 0; i < listeners.size(); i++)
                  try
                  {
                     ((HttpSessionListener) listeners.get(0)).sessionCreated(event);
                  }
                  catch (ClassCastException cce)
                  {
                     // log("Wrong session listener type."+cce);
                  }
                  catch (NullPointerException npe)
                  {
                     // log("Null session listener.");
                  }
            }
         }
      }

      /**
       * something hack, to update servlet context since session created out of scope
       *
       * @param sc
       */
      public synchronized void setServletContext(ServletContext sc)
      {
         // System.err.println("ctx to:"+servletContext); //!!!
         servletContext = sc;
      }

      private void notifyListeners()
      {
         if (listeners != null)
         {
            HttpSessionEvent event = new HttpSessionEvent(this);
            for (int i = 0; i < listeners.size(); i++)
               try
               {
                  ((HttpSessionListener) listeners.get(i)).sessionDestroyed(event);
               }
               catch (ClassCastException cce)
               {
                  // log("Wrong session listener type."+cce);
               }
               catch (NullPointerException npe)
               {
                  // log("Null session listener.");
               }
         }
      }

      private void setExpired(boolean expired)
      {
         this.expired = expired;
      }

      boolean isValid()
      {
         return !expired;
      }

      boolean checkExpired()
      {
         return inactiveInterval > 0 && (inactiveInterval * 1000 < System.currentTimeMillis() - lastAccessTime);
      }

      void userTouch()
      {
         if (isValid())
            lastAccessTime = System.currentTimeMillis();
         else
            throw new IllegalStateException();
      }

      // storing session in format
      // id:latency:contextname:tttt
      // entry:base64 ser data
      // entry:base64 ser data
      // $$
      void save(Writer w) throws IOException
      {
         if (expired)
            return;
         // can't use append because old JDK
         w.write(id);
         w.write(':');
         w.write(Integer.toString(inactiveInterval));
         w.write(':');
         w.write(servletContext == null || servletContext.getServletContextName() == null ? "" : servletContext
                 .getServletContextName());
         w.write(':');
         w.write(Long.toString(lastAccessTime));
         w.write("\r\n");
         Enumeration e = getAttributeNames();
         ByteArrayOutputStream os = new ByteArrayOutputStream(1024 * 16);
         while (e.hasMoreElements())
         {
            String aname = (String) e.nextElement();
            Object so = get(aname);
            if (so instanceof Serializable)
            {
               os.reset();
               ObjectOutputStream oos = new ObjectOutputStream(os);
               try
               {
                  oos.writeObject(so);
                  w.write(aname);
                  w.write(":");
                  w.write(Utils.base64Encode(os.toByteArray()));
                  w.write("\r\n");
               }
               catch (IOException ioe)
               {
                  servletContext.log("Problem storing a session value of " + aname, ioe);
               }
            }
            else
               servletContext.log("Non serializable object " + so.getClass().getName() + " skiped in storing of " + aname, null);
            if (so instanceof HttpSessionActivationListener)
               ((HttpSessionActivationListener) so).sessionWillPassivate(new HttpSessionEvent(this));
         }
         w.write("$$\r\n");
      }

      static AcmeSession restore(BufferedReader r, int inactiveInterval, ServletContext servletContext,
                                 HttpSessionContext sessionContext) throws IOException
      {
         String s = r.readLine();
         if (s == null) // eos
            return null;
         int cp = s.indexOf(':');
         if (cp < 0)
            throw new IOException("Invalid format for a session header, no session id: " + s);
         String id = s.substring(0, cp);
         int cp2 = s.indexOf(':', cp + 1);
         if (cp2 < 0)
            throw new IOException("Invalid format for a session header, no latency: " + s);
         try
         {
            inactiveInterval = Integer.parseInt(s.substring(cp + 1, cp2));
         }
         catch (NumberFormatException nfe)
         {
            servletContext.log("Session latency is invalid:" + s.substring(cp + 1, cp2) + " " + nfe);
         }
         cp = s.indexOf(':', cp2 + 1);
         if (cp < 0)
            throw new IOException("Invalid format for a session header, context name: " + s);
         String contextName = s.substring(cp2 + 1, cp);
         // consider servletContext.getContext("/"+contextName)
         AcmeSession result = new AcmeSession(id, inactiveInterval, contextName.length() == 0 ? servletContext
                 : null, sessionContext);
         try
         {
            result.lastAccessTime = Long.parseLong(s.substring(cp + 1));
         }
         catch (NumberFormatException nfe)
         {
            servletContext.log("Last access time is invalid:" + s.substring(cp + 1) + " " + nfe);
         }
         do
         {
            s = r.readLine();
            if (s == null)
               throw new IOException("Unexpected end of a stream.");
            if ("$$".equals(s))
               return result;
            cp = s.indexOf(':');
            if (cp < 0)
               throw new IOException("Invalid format for a session entry: " + s);
            String aname = s.substring(0, cp);
            // if (lazyRestore)
            // result.put(aname, s.substring(cp+1));
            ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(Utils.decode64(s
                    .substring(cp + 1))));
            Throwable restoreError;
            try
            {
               Object so;
               result.put(aname, so = ois.readObject());
               restoreError = null;
               if (so instanceof HttpSessionActivationListener)
                  ((HttpSessionActivationListener) so).sessionDidActivate(new HttpSessionEvent(result));

            }
            catch (ClassNotFoundException cnfe)
            {
               restoreError = cnfe;

            }
            catch (NoClassDefFoundError ncdfe)
            {
               restoreError = ncdfe;
            }
            catch (IOException ioe)
            {
               restoreError = ioe;
            }
            if (restoreError != null)
               servletContext.log("Can't restore :" + aname + ", " + restoreError);
         } while (true);
      }
   }

   protected static class LocaleWithWeight implements Comparable
   {
      protected float weight; // should be int

      protected Locale locale;

      LocaleWithWeight(Locale l, float w)
      {
         locale = l;
         weight = w;
         // System.err.println("Created "+l+", with:"+w);
      }

      public int compareTo(Object o)
      {
         if (o instanceof LocaleWithWeight)
            return (int) (((LocaleWithWeight) o).weight - weight) * 100;
         throw new IllegalArgumentException();
      }

      public Locale getLocale()
      {
         return locale;
      }
   }

   protected static class AcceptLocaleEnumeration implements Enumeration
   {
      Iterator i;

      public AcceptLocaleEnumeration(TreeSet/* <LocaleWithWeight> */ts)
      {
         i = ts.iterator();
      }

      public boolean hasMoreElements()
      {
         return i.hasNext();
      }

      public Object nextElement()
      {
         return ((LocaleWithWeight) i.next()).getLocale();
         /*
             * Locale l =((LocaleWithWeight)i.next()).getLocale(); System.err.println("Returned l:"+l); return l;
             */
      }
   }

   // TODO: reconsider implementation by providing
   // inner class implementing HttpSessionContext
   // and returning it on request
   // to avoid casting this class to Hashtable

   protected static class HttpSessionContextImpl extends Hashtable implements HttpSessionContext
   {

      public java.util.Enumeration getIds()
      {
         return keys();
      }

      public HttpSession getSession(java.lang.String sessionId)
      {
         return (HttpSession) get(sessionId);
      }

      void save(Writer w) throws IOException
      {
         Enumeration e = elements();
         while (e.hasMoreElements())
            ((AcmeSession) e.nextElement()).save(w);
      }

      static HttpSessionContextImpl restore(BufferedReader br, int inactiveInterval, ServletContext servletContext)
              throws IOException
      {
         HttpSessionContextImpl result = new HttpSessionContextImpl();
         AcmeSession session;
         while ((session = AcmeSession.restore(br, inactiveInterval, servletContext, result)) != null)
            if (session.checkExpired() == false)
               result.put(session.getId(), session);
         return result;
      }
   }
}
